@logomarks/logo3d 0.0.0-stage → 0.1.0

package/src/worker/client.js

@@ -0,0 +1,83 @@
+/**
+ * @module @logomarks/logo3d/worker/client
+ *
+ * Builds geometry in the worker, latest request wins: while one build runs, a new request replaces any waiting one
+ * (the replaced one rejects with an `AbortError`), so dragging a slider never queues up stale builds. Without a
+ * worker it builds on the main thread, one request at a time, the same way.
+ */
+
+import { makeBuild } from './build.js';
+
+/**
+ * An `AbortError` for a request that a newer one replaced.
+ *
+ * @returns {Error} The error.
+ */
+const superseded = () => Object.assign(new Error('logo3d: replaced by a newer request'), { name: 'AbortError' });
+
+/**
+ * A builder.
+ *
+ * @param {(() => import('./client.js').WorkerLike) | null} [makeWorker] Makes the worker (null: build on the main
+ *   thread).
+ * @returns {import('./client.js').Builder} The builder.
+ */
+export function createBuilder(makeWorker = null) {
+	/** @type {import('./client.js').WorkerLike | null} */
+	const worker = makeWorker ? makeWorker() : null;
+	const local = worker ? null : makeBuild();
+	/** @typedef {{ req: import('./client.js').BuildRequest, resolve: (r: import('./client.js').BuildResult) => void, reject: (e: Error) => void }} Job */
+	/** @type {Job | null} */
+	let waiting = null;
+	/** @type {(Job & { id: number }) | null} */
+	let running = null;
+	let ids = 0;
+
+	function pump() {
+		if (running || !waiting) return;
+		const job = { ...waiting, id: ++ids };
+		waiting = null;
+		running = job;
+		if (worker) worker.postMessage({ id: job.id, svg: job.req.svg, options: job.req.options });
+		else
+			Promise.resolve().then(() => {
+				try {
+					finish(job.id, { result: /** @type {NonNullable<typeof local>} */ (local)(job.req) });
+				} catch (err) {
+					finish(job.id, { error: err instanceof Error ? err.message : String(err) });
+				}
+			});
+	}
+
+	/**
+	 * A build is done.
+	 *
+	 * @param {number} id The build.
+	 * @param {{ result?: import('./client.js').BuildResult, error?: string }} reply What came back.
+	 */
+	function finish(id, reply) {
+		if (!running || running.id !== id) return;
+		const job = running;
+		running = null;
+		if (reply.error !== undefined) job.reject(new Error(reply.error));
+		else job.resolve(/** @type {import('./client.js').BuildResult} */ (reply.result));
+		pump();
+	}
+
+	if (worker) worker.onmessage = (e) => finish(e.data.id, e.data);
+
+	return {
+		build(req) {
+			return new Promise((resolve, reject) => {
+				waiting?.reject(superseded());
+				waiting = { req, resolve, reject };
+				pump();
+			});
+		},
+		dispose() {
+			waiting?.reject(superseded());
+			waiting = null;
+			worker?.terminate();
+		},
+	};
+}

package/src/worker/worker.d.ts

@@ -0,0 +1,2 @@
+/** The geometry worker's entry: messages `{ id, svg, options }`, replies `{ id, result }` or `{ id, error }`. */
+export {};

package/src/worker/worker.js

@@ -0,0 +1,23 @@
+/**
+ * @module @logomarks/logo3d/worker
+ *
+ * The geometry worker: a module worker that reads SVGs and extrudes them off the main thread. Each message is
+ * `{ id, svg, options }`; each reply `{ id, result }` (its arrays transferred) or `{ id, error }`. Load it as a
+ * same-origin module worker (Vite: `import Worker from '@logomarks/logo3d/worker?worker'`); no blob: URL, no
+ * WebAssembly. Use it through `createBuilder`, which keeps only the latest request.
+ */
+
+import { makeBuild, transferables } from './build.js';
+
+const build = makeBuild();
+const scope = /** @type {{ onmessage: ((e: MessageEvent) => void) | null, postMessage(m: unknown, t?: Transferable[]): void }} */ (/** @type {unknown} */ (globalThis));
+
+scope.onmessage = (e) => {
+	const { id, svg, options } = e.data;
+	try {
+		const result = build({ svg, options });
+		scope.postMessage({ id, result }, transferables(result));
+	} catch (err) {
+		scope.postMessage({ id, error: err instanceof Error ? err.message : String(err) });
+	}
+};