@forgeax/engine-font 0.0.0-dev.8d955ade1c79

package/src/node-msdf-worker.mjs

@@ -0,0 +1,38 @@
+import { parentPort } from 'node:worker_threads';
+
+if (parentPort === null) {
+  throw new Error('the MSDF Node worker requires worker_threads.parentPort');
+}
+
+const listeners = new Map();
+const endpoint = globalThis;
+
+class NodeImageData {
+  constructor(data, width, height) {
+    this.data = data;
+    this.width = width;
+    this.height = height;
+  }
+}
+
+endpoint.ImageData = NodeImageData;
+endpoint.addEventListener = (type, listener) => {
+  if (type !== 'message') return;
+  const handler = (data) => listener({ data, origin: '*' });
+  listeners.set(listener, handler);
+  parentPort.on('message', handler);
+};
+
+endpoint.removeEventListener = (type, listener) => {
+  if (type !== 'message') return;
+  const handler = listeners.get(listener);
+  if (handler === undefined) return;
+  listeners.delete(listener);
+  parentPort.off('message', handler);
+};
+
+endpoint.postMessage = (message, transferList = []) => {
+  parentPort.postMessage(message, [...transferList]);
+};
+
+await import('@zappar/msdf-generator/worker.js');

package/src/node-worker-adapter.ts

@@ -0,0 +1,41 @@
+import { Worker } from 'node:worker_threads';
+
+interface MessageEventLike {
+  readonly data: unknown;
+  readonly origin: string;
+}
+
+type MessageListener = (event: MessageEventLike) => void;
+
+/** Comlink's browser Worker-shaped endpoint backed by a Node worker thread. */
+export class NodeWorkerAdapter {
+  private readonly worker: Worker;
+  private readonly listeners = new Map<MessageListener, (data: unknown) => void>();
+
+  public constructor(url: string | URL) {
+    this.worker = new Worker(url);
+  }
+
+  public postMessage(message: unknown, transferList: readonly ArrayBuffer[] = []): void {
+    this.worker.postMessage(message, [...transferList]);
+  }
+
+  public addEventListener(type: string, listener: MessageListener): void {
+    if (type !== 'message') return;
+    const handler = (data: unknown) => listener({ data, origin: '*' });
+    this.listeners.set(listener, handler);
+    this.worker.on('message', handler);
+  }
+
+  public removeEventListener(type: string, listener: MessageListener): void {
+    if (type !== 'message') return;
+    const handler = this.listeners.get(listener);
+    if (handler === undefined) return;
+    this.listeners.delete(listener);
+    this.worker.off('message', handler);
+  }
+
+  public terminate(): Promise<number> {
+    return this.worker.terminate();
+  }
+}

package/src/runtime/font-decoder.ts

@@ -0,0 +1,70 @@
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import {
+  type AssetDecoderContribution,
+  type AssetKind,
+  err,
+  type FontAsset,
+  ok,
+} from '@forgeax/engine-types';
+
+function parseGuid(value: unknown): FontAsset['atlas'] | undefined {
+  if (value instanceof Uint8Array && value.length === 16) return value as FontAsset['atlas'];
+  if (
+    Array.isArray(value) &&
+    value.length === 16 &&
+    value.every((item) => Number.isInteger(item) && item >= 0 && item <= 255)
+  ) {
+    return Uint8Array.from(value) as FontAsset['atlas'];
+  }
+  if (typeof value !== 'string') return undefined;
+  const parsed = AssetGuid.parse(value);
+  return parsed.ok ? parsed.value : undefined;
+}
+
+function validCommon(value: unknown): value is FontAsset['common'] {
+  if (value === null || typeof value !== 'object') return false;
+  const common = value as Record<string, unknown>;
+  return ['lineHeight', 'base', 'distanceRange', 'pxRange', 'atlasWidth', 'atlasHeight'].every(
+    (key) => typeof common[key] === 'number' && Number.isFinite(common[key]),
+  );
+}
+
+export const fontContribution: AssetDecoderContribution<FontAsset, 'font'> = {
+  kind: { kind: 'font' } as AssetKind<FontAsset, 'font'>,
+  consumer: 'GlyphTextLayout',
+  decoder: {
+    async decode({ envelope }) {
+      const payload = envelope.payload as unknown;
+      if (payload !== null && typeof payload === 'object') {
+        const source = payload as Record<string, unknown>;
+        const atlas = parseGuid(source.atlas ?? source.atlasGuid);
+        const sampler = parseGuid(source.sampler ?? source.samplerGuid);
+        if (
+          (source.kind === undefined || source.kind === 'font') &&
+          atlas !== undefined &&
+          sampler !== undefined &&
+          source.glyphs !== null &&
+          typeof source.glyphs === 'object' &&
+          validCommon(source.common)
+        ) {
+          return ok({
+            kind: 'font',
+            atlas,
+            sampler,
+            glyphs: source.glyphs as FontAsset['glyphs'],
+            common: source.common,
+            ...(source.notdef === undefined
+              ? {}
+              : { notdef: source.notdef as NonNullable<FontAsset['notdef']> }),
+          });
+        }
+      }
+      return err({
+        code: 'asset-package-invalid',
+        expected: 'a font payload with atlas and sampler references',
+        hint: 'recook the font atlas and publish its local sub-assets',
+        detail: { guid: envelope.guid, reason: 'font owner validation failed' },
+      });
+    },
+  },
+};