@forgeax/engine-font 0.1.2

package/src/__tests__/font-local-artifacts.test.ts

@@ -0,0 +1,280 @@
+import { ImporterRegistry, type RunImportMeta, runImport } from '@forgeax/engine-import';
+import type { ImportSubAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { BakeAtlas, MsdfGenerator } from '../cli-font.js';
+import { fontImporter } from '../font-importer.js';
+import { fontContribution } from '../runtime/font-decoder.js';
+
+const ATLAS_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d45c';
+const SAMPLER_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d45e';
+const FONT_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d45d';
+const DUPLICATE_ATLAS_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d460';
+const DUPLICATE_SAMPLER_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d461';
+const DUPLICATE_FONT_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d462';
+const EXPECTED_TOPOLOGY = 'exactly one texture, one sampler, and one font subAsset';
+
+const atlas: BakeAtlas = {
+  texture: { width: 1, height: 1, data: new Uint8Array([1, 2, 3, 4]) },
+  glyphs: [],
+  metrics: { lineHeight: 16, ascender: 12 },
+  textureSize: [1, 1],
+  fieldRange: 4,
+};
+
+interface Lifecycle {
+  readSource: number;
+  factory: number;
+  generateAtlas: number;
+  dispose: number;
+}
+
+function declaration(
+  guid: string,
+  kind: string,
+  sourceIndex: number,
+  sourceKey = `font:${kind}`,
+): ImportSubAsset {
+  return { guid, sourceIndex, sourceKey, kind };
+}
+
+function validSubAssets(): readonly ImportSubAsset[] {
+  return [
+    declaration(ATLAS_GUID, 'texture', 0),
+    declaration(SAMPLER_GUID, 'sampler', 1),
+    declaration(FONT_GUID, 'font', 2),
+  ];
+}
+
+function registry(): ImporterRegistry {
+  const importers = new ImporterRegistry();
+  importers.register(fontImporter);
+  return importers;
+}
+
+function meta(subAssets: readonly ImportSubAsset[], lifecycle: Lifecycle): RunImportMeta {
+  const generatorFactory = async (): Promise<MsdfGenerator> => {
+    lifecycle.factory += 1;
+    return {
+      generateAtlas: async () => {
+        lifecycle.generateAtlas += 1;
+        return atlas;
+      },
+      dispose: async () => {
+        lifecycle.dispose += 1;
+      },
+    };
+  };
+  return {
+    importer: 'font',
+    source: 'fonts/test.ttf',
+    subAssets,
+    importSettings: { generatorFactory },
+  };
+}
+
+function fs(lifecycle: Lifecycle, shouldRefuse: () => boolean = () => false) {
+  return {
+    readSource: async () => {
+      lifecycle.readSource += 1;
+      if (lifecycle.readSource === 2 && shouldRefuse()) {
+        return { ok: false as const, error: new Error('transient font source refusal') };
+      }
+      return { ok: true as const, value: new Uint8Array([0, 1, 0, 0]) };
+    },
+  };
+}
+
+function expectTopologyFailure(
+  result: Awaited<ReturnType<typeof runImport>>,
+  actual: string,
+): void {
+  expect(result.ok).toBe(false);
+  if (result.ok) return;
+  expect(result.error.code).toBe('source-validation-failed');
+  if (!('diagnostics' in result.error.detail)) return;
+  expect(result.error.detail.diagnostics).toHaveLength(1);
+  expect(result.error.detail.diagnostics[0]).toMatchObject({
+    code: 'font-required-subasset-topology',
+    severity: 'error',
+    sourcePath: 'fonts/test.ttf#subAssets',
+    rule: 'font-required-subasset-topology',
+    expected: EXPECTED_TOPOLOGY,
+    actual,
+  });
+}
+
+describe('font asset-local artifacts', () => {
+  it('exposes the font owner contribution for glyph layout', () => {
+    expect(fontContribution.kind.kind).toBe('font');
+    expect(fontContribution.consumer).toBe('GlyphTextLayout');
+  });
+  const invalidTopologyCases = [
+    {
+      name: 'missing texture',
+      actual: 'texture=0, sampler=1, font=1',
+      subAssets: [declaration(SAMPLER_GUID, 'sampler', 1), declaration(FONT_GUID, 'font', 2)],
+    },
+    {
+      name: 'missing sampler',
+      actual: 'texture=1, sampler=0, font=1',
+      subAssets: [declaration(ATLAS_GUID, 'texture', 0), declaration(FONT_GUID, 'font', 2)],
+    },
+    {
+      name: 'missing font',
+      actual: 'texture=1, sampler=1, font=0',
+      subAssets: [declaration(ATLAS_GUID, 'texture', 0), declaration(SAMPLER_GUID, 'sampler', 1)],
+    },
+    {
+      name: 'duplicate texture',
+      actual: 'texture=2, sampler=1, font=1',
+      subAssets: [
+        declaration(ATLAS_GUID, 'texture', 0, 'font:texture:0'),
+        declaration(DUPLICATE_ATLAS_GUID, 'texture', 1, 'font:texture:1'),
+        declaration(SAMPLER_GUID, 'sampler', 2),
+        declaration(FONT_GUID, 'font', 3),
+      ],
+    },
+    {
+      name: 'duplicate sampler',
+      actual: 'texture=1, sampler=2, font=1',
+      subAssets: [
+        declaration(ATLAS_GUID, 'texture', 0),
+        declaration(SAMPLER_GUID, 'sampler', 1, 'font:sampler:0'),
+        declaration(DUPLICATE_SAMPLER_GUID, 'sampler', 2, 'font:sampler:1'),
+        declaration(FONT_GUID, 'font', 3),
+      ],
+    },
+    {
+      name: 'duplicate font',
+      actual: 'texture=1, sampler=1, font=2',
+      subAssets: [
+        declaration(ATLAS_GUID, 'texture', 0),
+        declaration(SAMPLER_GUID, 'sampler', 1),
+        declaration(FONT_GUID, 'font', 2, 'font:font:0'),
+        declaration(DUPLICATE_FONT_GUID, 'font', 3, 'font:font:1'),
+      ],
+    },
+  ] as const;
+
+  for (const topologyCase of invalidTopologyCases) {
+    it(`refuses ${topologyCase.name} before source and generator work`, async () => {
+      const lifecycle: Lifecycle = { readSource: 0, factory: 0, generateAtlas: 0, dispose: 0 };
+      const result = await runImport(
+        meta(topologyCase.subAssets, lifecycle),
+        registry(),
+        fs(lifecycle),
+      );
+
+      expectTopologyFailure(result, topologyCase.actual);
+      expect(lifecycle).toEqual({ readSource: 1, factory: 0, generateAtlas: 0, dispose: 0 });
+    });
+  }
+
+  it('repairs the same meta in one registry/process and publishes complete local artifacts', async () => {
+    const lifecycle: Lifecycle = { readSource: 0, factory: 0, generateAtlas: 0, dispose: 0 };
+    const importers = registry();
+    const input = meta(
+      [declaration(ATLAS_GUID, 'texture', 0), declaration(FONT_GUID, 'font', 2)],
+      lifecycle,
+    );
+    const refused = await runImport(input, importers, fs(lifecycle));
+    expectTopologyFailure(refused, 'texture=1, sampler=0, font=1');
+
+    const retry = await runImport(
+      { ...input, subAssets: validSubAssets() },
+      importers,
+      fs(lifecycle),
+    );
+    expect(retry.ok).toBe(true);
+    if (!retry.ok || 'skipped' in retry.value) return;
+
+    const assets = retry.value.pack.assets;
+    expect(assets.map((asset) => asset.kind)).toEqual(['texture', 'sampler', 'font']);
+    const atlasAsset = assets.find((asset) => asset.guid === ATLAS_GUID);
+    expect(atlasAsset).toBeDefined();
+    if (atlasAsset === undefined) return;
+    const samplerAsset = assets.find((asset) => asset.guid === SAMPLER_GUID);
+    expect(samplerAsset?.kind).toBe('sampler');
+    const fontAsset = assets.find((asset) => asset.guid === FONT_GUID);
+    const body = atlasAsset.artifacts.atlas;
+    expect(body).toBeDefined();
+    if (body === undefined) return;
+    expect(body.mediaType).toBe('application/octet-stream');
+    expect(body).not.toHaveProperty('assetCodec');
+    expect(body.bytes).toBeInstanceOf(Uint8Array);
+    expect(body.bytes).toEqual(atlas.texture.data);
+    expect(body).not.toHaveProperty('path');
+    expect(body).not.toHaveProperty('integrity');
+    expect(fontAsset?.refs).toEqual([ATLAS_GUID, SAMPLER_GUID]);
+    expect(fontAsset?.payload).toMatchObject({
+      atlasGuid: ATLAS_GUID,
+      samplerGuid: SAMPLER_GUID,
+    });
+    expect(lifecycle).toEqual({ readSource: 3, factory: 1, generateAtlas: 1, dispose: 1 });
+  });
+
+  it('preserves importer source-read failure and retries the same Meta without stale publication', async () => {
+    const lifecycle: Lifecycle = { readSource: 0, factory: 0, generateAtlas: 0, dispose: 0 };
+    const importers = registry();
+    let refuseSecondRead = true;
+    const input = meta(validSubAssets(), lifecycle);
+    const reader = fs(lifecycle, () => refuseSecondRead);
+
+    const refused = await runImport(input, importers, reader);
+
+    expect(refused.ok).toBe(false);
+    expect(refused).not.toHaveProperty('value');
+    if (refused.ok) return;
+    expect(refused.error).toMatchObject({
+      code: 'source-read-failed',
+      expected: 'readable source file at meta.source "fonts/test.ttf"',
+      detail: {
+        source: 'fonts/test.ttf',
+        reason: 'transient font source refusal',
+      },
+    });
+    expect(refused.error.code).not.toBe('import-internal-error');
+    expect(lifecycle).toEqual({ readSource: 2, factory: 0, generateAtlas: 0, dispose: 0 });
+
+    refuseSecondRead = false;
+    const retry = await runImport(input, importers, reader);
+
+    expect(retry.ok).toBe(true);
+    if (!retry.ok || 'skipped' in retry.value) return;
+    expect(retry.value.product.sourceDependencies).toEqual(['fonts/test.ttf']);
+    expect(retry.value.pack.assets).toHaveLength(3);
+    expect(
+      retry.value.pack.assets.map(({ guid, kind, sourceKey, sourceIndex }) => ({
+        guid,
+        kind,
+        sourceKey,
+        sourceIndex,
+      })),
+    ).toEqual([
+      { guid: ATLAS_GUID, kind: 'texture', sourceKey: 'font:texture', sourceIndex: 0 },
+      { guid: SAMPLER_GUID, kind: 'sampler', sourceKey: 'font:sampler', sourceIndex: 1 },
+      { guid: FONT_GUID, kind: 'font', sourceKey: 'font:font', sourceIndex: 2 },
+    ]);
+    const atlasAsset = retry.value.pack.assets[0];
+    expect(atlasAsset?.artifacts.atlas).toMatchObject({
+      mediaType: 'application/octet-stream',
+      bytes: atlas.texture.data,
+    });
+    expect(retry.value.pack.assets[2]).toMatchObject({
+      refs: [ATLAS_GUID, SAMPLER_GUID],
+      payload: { atlasGuid: ATLAS_GUID, samplerGuid: SAMPLER_GUID },
+    });
+    expect(retry.value.cookProducts).toHaveLength(3);
+    expect(new Set(retry.value.cookProducts.map(({ guid }) => guid)).size).toBe(3);
+
+    const repeated = await runImport(input, importers, reader);
+
+    expect(repeated.ok).toBe(true);
+    if (!repeated.ok || 'skipped' in repeated.value) return;
+    expect(repeated.value.product.assets).toEqual(retry.value.product.assets);
+    expect(repeated.value.pack.assets).toEqual(retry.value.pack.assets);
+    expect(repeated.value.cookProducts).toEqual(retry.value.cookProducts);
+    expect(repeated.value.pack.assets.filter(({ guid }) => guid === FONT_GUID)).toHaveLength(1);
+    expect(lifecycle).toEqual({ readSource: 6, factory: 2, generateAtlas: 2, dispose: 2 });
+  });
+});