Loading files
8d9aed881This file is pinned to the selected release. Download the original to open it in your design tool.
/// <reference lib="webworker" />
// three/examples/jsm/loaders/SVGLoader uses DOMParser internally; workers don't provide it.
// Provide a small polyfill so batch generation can extrude SVG icons.
import { DOMParser as XmldomDOMParser } from '@xmldom/xmldom'
if (!(globalThis as any).DOMParser) {
;(globalThis as any).DOMParser = XmldomDOMParser as any
}
import type { AppState } from '../state/types'
import { exportTo3MF } from 'threejs-exporter-pc'
import { zipSync } from 'fflate'
import { registerCustomFonts } from './fonts'
import {
type GenerationInput,
BaseGeometryCache,
type ResolvedKeycap,
resolveKeycap,
safeFileName,
buildKeycapGroup,
} from './keycap-builder'
export type WorkerRequest =
| { type: 'generate'; payload: GeneratePayload }
| { type: 'zip'; payload: ZipPayload }
| { type: 'cancel' }
export interface GeneratePayload {
output: 'batch' | 'preview'
state: AppState
stlBuffersByModelId: Record<string, ArrayBuffer | null>
items: GenerationInput[]
}
export interface ZipPayload {
files: Record<string, Uint8Array>
}
export type WorkerResponse =
| { type: 'batch-item-start'; payload: { keyId: string } }
| { type: 'batch-progress'; payload: { keyId: string } }
| { type: 'batch-complete'; payload: { files: Record<string, Uint8Array> } }
| { type: 'preview-complete'; payload: { geometry: any } }
| { type: 'zip-complete'; payload: { zipData: Uint8Array } }
| { type: 'error'; payload: { message: string } }
let cancelled = false
function checkCancelled(message = 'Generation cancelled'): void {
if (cancelled) throw new Error(message)
}
async function yieldWithCancellationCheck(message?: string): Promise<void> {
await new Promise(r => setTimeout(r, 0))
checkCancelled(message)
}
async function handleGenerate(payload: GeneratePayload): Promise<void> {
const { output, state, stlBuffersByModelId, items } = payload
if (!items || items.length === 0) {
throw new Error('No items to generate')
}
registerCustomFonts(state.customFonts)
const geometryCache = new BaseGeometryCache()
if (output === 'preview') {
await handlePreviewGeneration(state, stlBuffersByModelId, items[0], geometryCache)
} else {
await handleBatchGeneration(state, stlBuffersByModelId, items, geometryCache)
}
}
async function handlePreviewGeneration(
state: AppState,
stlBuffersByModelId: Record<string, ArrayBuffer | null>,
item: GenerationInput,
geometryCache: BaseGeometryCache
): Promise<void> {
checkCancelled('Generation cancelled')
const resolved = resolveKeycap(state, item)
if (!resolved) throw new Error('Failed to resolve keycap')
try {
const baseGeom = await geometryCache.get(resolved.model, stlBuffersByModelId)
checkCancelled('Generation cancelled')
const group = await buildKeycapGroup(resolved, baseGeom, () => yieldWithCancellationCheck('Generation cancelled'))
// Use JSON export for preview to avoid 3MF overhead/issues
const json = group.toJSON()
if (!cancelled) {
self.postMessage({ type: 'preview-complete', payload: { geometry: json } } satisfies WorkerResponse)
}
} catch (error) {
throw new Error(`${formatResolvedKeycapContext('Preview failed for', resolved)}: ${asErrorMessage(error)}`)
}
}
async function handleBatchGeneration(
state: AppState,
stlBuffersByModelId: Record<string, ArrayBuffer | null>,
items: GenerationInput[],
geometryCache: BaseGeometryCache
): Promise<void> {
const files: Record<string, Uint8Array> = {}
for (const item of items) {
checkCancelled('Generation cancelled')
self.postMessage({
type: 'batch-item-start',
payload: { keyId: item.kind === 'keyId' ? item.keyId : '__template__' },
} satisfies WorkerResponse)
let resolved: ResolvedKeycap | null = null
try {
resolved = resolveKeycap(state, item)
if (!resolved) throw new Error(`Failed to resolve keycap from ${formatGenerationInput(item)}`)
const resolvedKey = resolved
const baseGeom = await geometryCache.get(resolvedKey.model, stlBuffersByModelId)
checkCancelled('Generation cancelled')
const group = await buildKeycapGroup(resolvedKey, baseGeom, () =>
yieldWithCancellationCheck('Generation cancelled')
)
const blob = await exportTo3MF(group)
const arrayBuffer = await blob.arrayBuffer()
// Generate filename with index for ordering
const keyIndex = state.keys.findIndex(k => k.id === resolvedKey.key.id) + 1
const filename = `${keyIndex}. ${safeFileName(resolvedKey.key.name)}.3mf`
files[filename] = new Uint8Array(arrayBuffer)
// Report progress
self.postMessage({
type: 'batch-progress',
payload: { keyId: resolvedKey.key.id },
} satisfies WorkerResponse)
} catch (error) {
if (resolved) {
throw new Error(`${formatResolvedKeycapContext('Generation failed for', resolved)}: ${asErrorMessage(error)}`)
}
throw new Error(`Generation failed for ${formatGenerationInput(item)}: ${asErrorMessage(error)}`)
}
}
checkCancelled('Generation cancelled')
if (!cancelled) {
const transfers = Object.values(files).map(u => u.buffer)
self.postMessage({ type: 'batch-complete', payload: { files } } satisfies WorkerResponse, transfers)
}
}
function asErrorMessage(error: unknown): string {
return error instanceof Error ? error.message : 'Unknown error'
}
function formatResolvedKeycapContext(prefix: string, resolved: ResolvedKeycap): string {
return `${prefix} key "${resolved.key.name}" (id: ${resolved.key.id}), template "${resolved.template.name}" (id: ${resolved.template.id}), model "${resolved.model.name}" (id: ${resolved.model.id})`
}
function formatGenerationInput(item: GenerationInput): string {
if (item.kind === 'keyId') return `key id "${item.keyId}"`
return `template "${item.template.name}" (id: ${item.template.id})`
}
async function handleZip(payload: ZipPayload): Promise<void> {
const { files } = payload
const zipData = zipSync(files)
if (!cancelled) {
self.postMessage({ type: 'zip-complete', payload: { zipData } } satisfies WorkerResponse, [zipData.buffer])
}
}
self.onmessage = async (e: MessageEvent<WorkerRequest>) => {
const { type } = e.data
if (type === 'cancel') {
cancelled = true
return
}
if (type === 'generate') {
cancelled = false
try {
await handleGenerate(e.data.payload)
} catch (error) {
if (!cancelled) {
self.postMessage({
type: 'error',
payload: {
message: error instanceof Error ? error.message : 'Generation failed.',
},
} satisfies WorkerResponse)
}
}
return
}
if (type === 'zip') {
cancelled = false
try {
await handleZip(e.data.payload)
} catch (error) {
if (!cancelled) {
self.postMessage({
type: 'error',
payload: {
message: error instanceof Error ? error.message : 'Zip failed.',
},
} satisfies WorkerResponse)
}
}
return
}
}