@flighthq/textshaper 0.1.0

package/src/textShaperRun.test.ts

@@ -0,0 +1,363 @@
+import type { FontMetrics, GlyphExtents, ShapedRun, TextShaperBackend } from '@flighthq/types';
+
+import { setTextShaperBackend } from './textShaper';
+import {
+  clearShapedRun,
+  createShapedRun,
+  getCodePointForGlyph,
+  getFontMetrics,
+  getFontMetricsInto,
+  getFontUnitScale,
+  getGlyphExtents,
+  getGlyphExtentsBatch,
+  getGlyphExtentsInto,
+  getGlyphIndexForCodePoint,
+  getGlyphName,
+  shapeTextRun,
+  shapeTextRunInto,
+} from './textShaperRun';
+
+const _testGlyphs = [
+  { cluster: 0, glyphId: 10, xAdvance: 8, xOffset: 0, yAdvance: 0, yOffset: 0 },
+  { cluster: 1, glyphId: 20, xAdvance: 7, xOffset: 0, yAdvance: 0, yOffset: 0 },
+];
+
+const _testRun: ShapedRun = {
+  advanceWidth: 15,
+  direction: 'LeftToRight',
+  font: null,
+  glyphCount: 2,
+  glyphs: _testGlyphs,
+  script: 'Latn',
+};
+
+const _testMetrics: FontMetrics = {
+  ascent: 10,
+  capHeight: 8,
+  descent: 3,
+  lineGap: 1,
+  underlinePosition: -2,
+  underlineThickness: 1,
+  unitsPerEm: 1000,
+  xHeight: 5,
+};
+
+const _testExtents: GlyphExtents = { height: 10, width: 6, xBearing: 0, yBearing: -8 };
+
+function _makeFullBackend(): TextShaperBackend {
+  return {
+    // Code point 65 ('A') maps to glyph 10 and back; everything else is unknown.
+    getCodePointForGlyph: (id) => (id === 10 ? 65 : -1),
+    getFontMetrics: () => ({ ..._testMetrics }),
+    getGlyphExtents: (id) => (id === 10 ? { ..._testExtents } : null),
+    getGlyphIndexForCodePoint: (cp) => (cp === 65 ? 10 : -1),
+    getGlyphName: (id) => (id === 10 ? 'A' : ''),
+    measureText: (text) => text.length * 8,
+    shapeRun: () => ({ ..._testRun, glyphs: [..._testGlyphs] }),
+  };
+}
+
+afterEach(() => {
+  setTextShaperBackend(null);
+});
+
+describe('clearShapedRun', () => {
+  it('resets all fields and empties the glyphs array', () => {
+    const run = createShapedRun();
+    (run as { advanceWidth: number }).advanceWidth = 42;
+    (run.glyphs as unknown[]).push(_testGlyphs[0]);
+    const returned = clearShapedRun(run);
+    expect(run.advanceWidth).toBe(0);
+    expect(run.glyphCount).toBe(0);
+    expect(run.glyphs).toHaveLength(0);
+    expect(run.direction).toBe('LeftToRight');
+    expect(run.script).toBe('');
+    expect(run.font).toBeNull();
+    expect(returned).toBe(run);
+  });
+
+  it('retains the same glyphs array reference after clearing', () => {
+    const run = createShapedRun();
+    const arr = run.glyphs;
+    clearShapedRun(run);
+    expect(run.glyphs).toBe(arr);
+  });
+});
+
+describe('createShapedRun', () => {
+  it('returns an empty run with zero advance width', () => {
+    const run = createShapedRun();
+    expect(run.advanceWidth).toBe(0);
+    expect(run.glyphCount).toBe(0);
+    expect(run.glyphs).toHaveLength(0);
+    expect(run.direction).toBe('LeftToRight');
+    expect(run.font).toBeNull();
+    expect(run.script).toBe('');
+  });
+
+  it('allocates a new run on each call', () => {
+    expect(createShapedRun()).not.toBe(createShapedRun());
+  });
+});
+
+describe('getCodePointForGlyph', () => {
+  it('returns -1 when no backend is set', () => {
+    expect(getCodePointForGlyph(10, {})).toBe(-1);
+  });
+
+  it('returns -1 when the backend does not implement getCodePointForGlyph', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(getCodePointForGlyph(10, {})).toBe(-1);
+  });
+
+  it('delegates to the backend and returns the resolved code point', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getCodePointForGlyph(10, {})).toBe(65);
+  });
+
+  it('returns -1 for glyph ids the backend cannot reverse-map', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getCodePointForGlyph(999, {})).toBe(-1);
+  });
+});
+
+describe('getFontMetrics', () => {
+  it('returns null when no backend is set', () => {
+    expect(getFontMetrics({})).toBeNull();
+  });
+
+  it('returns null when the backend is advances-only (no getFontMetrics)', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(getFontMetrics({})).toBeNull();
+  });
+
+  it('delegates to the backend', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const m = getFontMetrics({ size: 16 });
+    expect(m).not.toBeNull();
+    expect(m!.ascent).toBe(10);
+    expect(m!.unitsPerEm).toBe(1000);
+  });
+});
+
+describe('getFontMetricsInto', () => {
+  it('returns false and does not modify out when no backend is set', () => {
+    const out: FontMetrics = { ..._testMetrics, ascent: 99 };
+    expect(getFontMetricsInto({}, out)).toBe(false);
+    expect(out.ascent).toBe(99);
+  });
+
+  it('writes all fields into out and returns true on success', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out = { ..._testMetrics };
+    expect(getFontMetricsInto({}, out)).toBe(true);
+    expect(out.ascent).toBe(_testMetrics.ascent);
+    expect(out.capHeight).toBe(_testMetrics.capHeight);
+  });
+});
+
+describe('getFontUnitScale', () => {
+  it('returns -1 when no backend is set', () => {
+    expect(getFontUnitScale({})).toBe(-1);
+  });
+
+  it('returns size / unitsPerEm', () => {
+    setTextShaperBackend(_makeFullBackend());
+    // default size is 12 per the function; unitsPerEm is 1000.
+    expect(getFontUnitScale({})).toBeCloseTo(12 / 1000);
+    expect(getFontUnitScale({ size: 20 })).toBeCloseTo(20 / 1000);
+  });
+});
+
+describe('getGlyphExtents', () => {
+  it('returns null when no backend is set', () => {
+    expect(getGlyphExtents(10, {})).toBeNull();
+  });
+
+  it('returns null when the backend is advances-only', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(getGlyphExtents(10, {})).toBeNull();
+  });
+
+  it('delegates to the backend', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const e = getGlyphExtents(10, {});
+    expect(e).not.toBeNull();
+    expect(e!.width).toBe(6);
+  });
+
+  it('returns null for unknown glyph ids', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getGlyphExtents(999, {})).toBeNull();
+  });
+});
+
+describe('getGlyphExtentsBatch', () => {
+  it('returns 0 and writes nothing when no backend is set', () => {
+    const out: GlyphExtents[] = [];
+    expect(getGlyphExtentsBatch([10, 20], {}, out)).toBe(0);
+  });
+
+  it('returns 0 when the backend is advances-only', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    const out: GlyphExtents[] = [];
+    expect(getGlyphExtentsBatch([10], {}, out)).toBe(0);
+  });
+
+  it('resolves known glyphs and counts only those that resolved', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out: GlyphExtents[] = [];
+    // 10 resolves; 999 is unknown.
+    const resolved = getGlyphExtentsBatch([10, 999], {}, out);
+    expect(resolved).toBe(1);
+    expect(out).toHaveLength(2);
+    expect(out[0].width).toBe(_testExtents.width);
+  });
+
+  it('writes zeroed extents for unknown glyphs so out is fully populated', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out: GlyphExtents[] = [];
+    getGlyphExtentsBatch([999, 10], {}, out);
+    expect(out[0]).toEqual({ height: 0, width: 0, xBearing: 0, yBearing: 0 });
+    expect(out[1].height).toBe(_testExtents.height);
+  });
+
+  it('returns 0 for an empty glyph id list without touching the backend', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out: GlyphExtents[] = [];
+    expect(getGlyphExtentsBatch([], {}, out)).toBe(0);
+    expect(out).toHaveLength(0);
+  });
+});
+
+describe('getGlyphExtentsInto', () => {
+  it('returns false and does not modify out when no backend is set', () => {
+    const out: GlyphExtents = { height: 1, width: 1, xBearing: 1, yBearing: 1 };
+    expect(getGlyphExtentsInto(10, {}, out)).toBe(false);
+    expect(out.width).toBe(1);
+  });
+
+  it('writes all fields into out and returns true on success', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out: GlyphExtents = { height: 0, width: 0, xBearing: 0, yBearing: 0 };
+    expect(getGlyphExtentsInto(10, {}, out)).toBe(true);
+    expect(out.width).toBe(_testExtents.width);
+    expect(out.height).toBe(_testExtents.height);
+    expect(out.yBearing).toBe(_testExtents.yBearing);
+  });
+});
+
+describe('getGlyphIndexForCodePoint', () => {
+  it('returns -1 when no backend is set', () => {
+    expect(getGlyphIndexForCodePoint(65, {})).toBe(-1);
+  });
+
+  it('returns -1 when the backend does not implement getGlyphIndexForCodePoint', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(getGlyphIndexForCodePoint(65, {})).toBe(-1);
+  });
+
+  it('delegates to the backend and returns the glyph id', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getGlyphIndexForCodePoint(65, {})).toBe(10);
+  });
+
+  it('returns -1 for code points with no glyph in the font', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getGlyphIndexForCodePoint(0x2603, {})).toBe(-1);
+  });
+});
+
+describe('getGlyphName', () => {
+  it('returns an empty string when no backend is set', () => {
+    expect(getGlyphName(10, {})).toBe('');
+  });
+
+  it('returns an empty string when the backend does not implement getGlyphName', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(getGlyphName(10, {})).toBe('');
+  });
+
+  it('delegates to the backend and returns the PostScript glyph name', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getGlyphName(10, {})).toBe('A');
+  });
+
+  it('returns an empty string for glyph ids the backend cannot name', () => {
+    setTextShaperBackend(_makeFullBackend());
+    expect(getGlyphName(999, {})).toBe('');
+  });
+});
+
+describe('shapeTextRun', () => {
+  it('returns null when no backend is set', () => {
+    expect(shapeTextRun('hi', {})).toBeNull();
+  });
+
+  it('returns null when the backend is advances-only (no shapeRun)', () => {
+    setTextShaperBackend({ measureText: (t) => t.length });
+    expect(shapeTextRun('hi', {})).toBeNull();
+  });
+
+  it('delegates to backend.shapeRun', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const run = shapeTextRun('ab', {});
+    expect(run).not.toBeNull();
+    expect(run!.glyphCount).toBe(2);
+    expect(run!.direction).toBe('LeftToRight');
+  });
+
+  it('passes options to the backend', () => {
+    let capturedOptions: unknown;
+    setTextShaperBackend({
+      measureText: () => 0,
+      shapeRun: (_t, _f, opts) => {
+        capturedOptions = opts;
+        return { ..._testRun, glyphs: [] };
+      },
+    });
+    shapeTextRun('x', {}, { direction: 'RightToLeft', script: 'Arab' });
+    expect(capturedOptions).toMatchObject({ direction: 'RightToLeft', script: 'Arab' });
+  });
+});
+
+describe('shapeTextRunInto', () => {
+  it('returns false and does not modify out when no backend is set', () => {
+    const out = createShapedRun();
+    expect(shapeTextRunInto('hi', {}, out)).toBe(false);
+    expect(out.glyphCount).toBe(0);
+  });
+
+  it('writes run fields and glyphs into out, returns true', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out = createShapedRun();
+    expect(shapeTextRunInto('ab', {}, out)).toBe(true);
+    expect(out.advanceWidth).toBe(15);
+    expect(out.glyphCount).toBe(2);
+    expect(out.glyphs).toHaveLength(2);
+    expect(out.glyphs[0].glyphId).toBe(10);
+    expect(out.script).toBe('Latn');
+  });
+
+  it('forwards options to the backend', () => {
+    let capturedOptions: unknown;
+    setTextShaperBackend({
+      measureText: () => 0,
+      shapeRun: (_t, _f, opts) => {
+        capturedOptions = opts;
+        return { ..._testRun, glyphs: [..._testGlyphs] };
+      },
+    });
+    const out = createShapedRun();
+    shapeTextRunInto('x', {}, out, { direction: 'RightToLeft', script: 'Arab' });
+    expect(capturedOptions).toMatchObject({ direction: 'RightToLeft', script: 'Arab' });
+  });
+
+  it('retains the existing glyphs array reference', () => {
+    setTextShaperBackend(_makeFullBackend());
+    const out = createShapedRun();
+    const originalGlyphs = out.glyphs;
+    shapeTextRunInto('ab', {}, out);
+    expect(out.glyphs).toBe(originalGlyphs);
+  });
+});

package/src/textShaperSignals.test.ts

@@ -0,0 +1,84 @@
+import type { TextShaperBackend } from '@flighthq/types';
+
+import { setTextShaperBackend } from './textShaper';
+import { disposeTextShaperSignals, enableTextShaperSignals, getTextShaperSignals } from './textShaperSignals';
+
+const _stubBackend: TextShaperBackend = { measureText: () => 0 };
+const _stubBackend2: TextShaperBackend = { measureText: () => 1 };
+
+afterEach(() => {
+  disposeTextShaperSignals();
+  setTextShaperBackend(null);
+});
+
+describe('disposeTextShaperSignals', () => {
+  it('is a no-op when signals have not been enabled', () => {
+    expect(() => disposeTextShaperSignals()).not.toThrow();
+  });
+  it('clears all listeners after dispose', () => {
+    const sigs = enableTextShaperSignals();
+    let fired = false;
+    sigs.onBackendChanged.emit = () => {
+      fired = true;
+    };
+    disposeTextShaperSignals();
+    setTextShaperBackend(_stubBackend);
+    expect(fired).toBe(false);
+  });
+  it('getTextShaperSignals returns null after dispose', () => {
+    enableTextShaperSignals();
+    disposeTextShaperSignals();
+    expect(getTextShaperSignals()).toBeNull();
+  });
+});
+
+describe('enableTextShaperSignals', () => {
+  it('returns a TextShaperSignals entity with onBackendChanged', () => {
+    const sigs = enableTextShaperSignals();
+    expect(sigs).not.toBeNull();
+    expect(typeof sigs.onBackendChanged).toBe('object');
+    expect(typeof sigs.onBackendChanged.emit).toBe('function');
+  });
+  it('is idempotent: returns the same entity on repeat calls', () => {
+    const s1 = enableTextShaperSignals();
+    const s2 = enableTextShaperSignals();
+    expect(s1).toBe(s2);
+  });
+});
+
+describe('getTextShaperSignals', () => {
+  it('returns null before signals are enabled', () => {
+    expect(getTextShaperSignals()).toBeNull();
+  });
+  it('returns the active signals entity after enabling', () => {
+    const sigs = enableTextShaperSignals();
+    expect(getTextShaperSignals()).toBe(sigs);
+  });
+});
+
+describe('setTextShaperBackend', () => {
+  it('emits onBackendChanged with the new backend when signals are enabled', () => {
+    const sigs = enableTextShaperSignals();
+    const received: (TextShaperBackend | null)[] = [];
+    sigs.onBackendChanged.emit = (b) => received.push(b);
+    setTextShaperBackend(_stubBackend);
+    expect(received).toEqual([_stubBackend]);
+  });
+  it('emits onBackendChanged with null when cleared', () => {
+    const sigs = enableTextShaperSignals();
+    const received: (TextShaperBackend | null)[] = [];
+    sigs.onBackendChanged.emit = (b) => received.push(b);
+    setTextShaperBackend(_stubBackend);
+    setTextShaperBackend(null);
+    expect(received).toEqual([_stubBackend, null]);
+  });
+  it('does not emit when signals are not enabled', () => {
+    // Verifies setTextShaperBackend does not throw when no signals enabled.
+    expect(() => setTextShaperBackend(_stubBackend2)).not.toThrow();
+  });
+  it('installs the backend', () => {
+    enableTextShaperSignals();
+    setTextShaperBackend(_stubBackend);
+    expect(_stubBackend).toBeDefined();
+  });
+});