@flighthq/text 0.1.0

package/src/textFormatFont.test.ts

@@ -0,0 +1,29 @@
+import { computeTextFormatFontString } from './textFormatFont';
+
+describe('computeTextFormatFontString', () => {
+  it('returns a CSS font string from format properties', () => {
+    const font = computeTextFormatFontString({ size: 16, font: 'Arial', bold: false, italic: false });
+    expect(font).toBe('normal normal 16px Arial');
+  });
+
+  it('includes bold and italic when set', () => {
+    const font = computeTextFormatFontString({ size: 12, font: 'sans-serif', bold: true, italic: true });
+    expect(font).toBe('italic bold 12px sans-serif');
+  });
+
+  it('uses defaults when size and font are omitted', () => {
+    const font = computeTextFormatFontString({});
+    expect(font).toContain('12px');
+    expect(font).toContain('serif');
+  });
+
+  it('uses italic style when italic is true', () => {
+    const font = computeTextFormatFontString({ italic: true });
+    expect(font).toMatch(/^italic /);
+  });
+
+  it('uses bold weight when bold is true', () => {
+    const font = computeTextFormatFontString({ bold: true });
+    expect(font).toContain(' bold ');
+  });
+});

package/src/textLabel.test.ts

@@ -0,0 +1,265 @@
+import { createRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRevision, getNodeLocalContentRevision } from '@flighthq/node';
+import { setTextLayoutMeasureProvider } from '@flighthq/textlayout';
+import type { Node, PartialNode, TextLabel } from '@flighthq/types';
+import { TextLabelKind } from '@flighthq/types';
+
+import {
+  appendTextLabelString,
+  computeTextLabelLocalBoundsRectangle,
+  createTextLabel,
+  createTextLabelData,
+  createTextLabelRuntime,
+  getTextLabelFormat,
+  getTextLabelRuntime,
+  getTextLabelString,
+  setTextLabelAutoSize,
+  setTextLabelFormat,
+  setTextLabelHeight,
+  setTextLabelString,
+  setTextLabelWidth,
+} from './textLabel';
+
+describe('appendTextLabelString', () => {
+  it('appends the value to the existing text', () => {
+    const text = createTextLabel({ data: { text: 'hello' } });
+    appendTextLabelString(text, ' world');
+    expect(text.data.text).toBe('hello world');
+  });
+
+  it('invalidates local content after append', () => {
+    const text = createTextLabel({ data: { text: 'hi' } });
+    const content = getNodeLocalContentRevision(text);
+    appendTextLabelString(text, '!');
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+  });
+
+  it('does not invalidate when value is empty', () => {
+    const text = createTextLabel({ data: { text: 'hi' } });
+    const content = getNodeLocalContentRevision(text);
+    appendTextLabelString(text, '');
+    expect(getNodeLocalContentRevision(text)).toBe(content);
+  });
+});
+
+describe('computeTextLabelLocalBoundsRectangle', () => {
+  afterEach(() => {
+    setTextLayoutMeasureProvider(null);
+  });
+
+  it('sets out dimensions from data width and height when autoSize is none', () => {
+    const text = createTextLabel({ data: { width: 200, height: 50 } });
+    const out = createRectangle();
+    computeTextLabelLocalBoundsRectangle(out, text as unknown as Node);
+    expect(out.x).toBe(0);
+    expect(out.width).toBe(200);
+    expect(out.height).toBe(50);
+  });
+
+  it('grows to the measured single run under autoSize left, anchored at the origin', () => {
+    setTextLayoutMeasureProvider((value) => value.length * 7);
+    const text = createTextLabel({ data: { autoSize: 'left', width: 200, height: 50 } });
+    setTextLabelString(text, 'hi');
+    const out = createRectangle();
+    computeTextLabelLocalBoundsRectangle(out, text as unknown as Node);
+    expect(out.x).toBe(0);
+    expect(out.width).toBeGreaterThan(0);
+    expect(out.width).toBeLessThan(200);
+  });
+
+  it('falls back to the fixed box under autoSize when no measure provider exists', () => {
+    const text = createTextLabel({ data: { autoSize: 'left', width: 200, height: 50 } });
+    setTextLabelString(text, 'hi');
+    const out = createRectangle();
+    computeTextLabelLocalBoundsRectangle(out, text as unknown as Node);
+    expect(out.width).toBe(200);
+    expect(out.height).toBe(50);
+  });
+});
+
+describe('createTextLabel', () => {
+  let text: TextLabel;
+
+  beforeEach(() => {
+    text = createTextLabel();
+  });
+
+  it('initializes default values', () => {
+    expect(text.data.text).toBe('');
+    expect(text.data.autoSize).toBe('none');
+    expect(text.data.width).toBe(100);
+    expect(text.data.height).toBe(100);
+    expect(text.data.textFormat).not.toBeNull();
+    expect(text.kind).toStrictEqual(TextLabelKind);
+  });
+
+  it('allows pre-defined values', () => {
+    const base: PartialNode<TextLabel> = {
+      data: {
+        autoSize: 'left',
+        text: 'foo',
+        width: 300,
+        height: 40,
+      },
+    };
+    const obj = createTextLabel(base);
+    expect(obj.data.autoSize).toStrictEqual(base.data!.autoSize);
+    expect(obj.data.text).toStrictEqual(base.data!.text);
+    expect(obj.data.width).toBe(300);
+    expect(obj.data.height).toBe(40);
+  });
+
+  it('returns a new object for better hidden-class performance', () => {
+    const base = {};
+    const obj = createTextLabel(base);
+    expect(obj).not.toStrictEqual(base);
+  });
+});
+
+describe('createTextLabelData', () => {
+  it('returns default values', () => {
+    const data = createTextLabelData();
+    expect(data.autoSize).toBe('none');
+    expect(data.height).toBe(100);
+    expect(data.text).toBe('');
+    expect(data.textFormat).not.toBeNull();
+    expect(data.width).toBe(100);
+  });
+
+  it('allows pre-defined values', () => {
+    const data = createTextLabelData({ autoSize: 'left', text: 'hello', width: 250, height: 30 });
+    expect(data.autoSize).toBe('left');
+    expect(data.text).toBe('hello');
+    expect(data.width).toBe(250);
+    expect(data.height).toBe(30);
+  });
+});
+
+describe('createTextLabelRuntime', () => {
+  it('returns a non-null runtime', () => {
+    const runtime = createTextLabelRuntime();
+    expect(runtime).not.toBeNull();
+  });
+
+  it('starts without attached layout runtime state', () => {
+    const runtime = createTextLabelRuntime();
+    expect(runtime.textLayout).toBeNull();
+  });
+
+  it('uses computeTextLabelLocalBoundsRectangle', () => {
+    const runtime = createTextLabelRuntime();
+    expect(runtime.computeLocalBoundsRectangle).toStrictEqual(computeTextLabelLocalBoundsRectangle);
+  });
+});
+
+describe('getTextLabelFormat', () => {
+  it('returns the textFormat field', () => {
+    const format = { size: 24, bold: true };
+    const text = createTextLabel({ data: { textFormat: format } });
+    expect(getTextLabelFormat(text)).toBe(text.data.textFormat);
+  });
+});
+
+describe('getTextLabelRuntime', () => {
+  it('returns the runtime for a TextLabel', () => {
+    const text = createTextLabel();
+    const runtime = getTextLabelRuntime(text);
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('getTextLabelString', () => {
+  it('returns the text field', () => {
+    const text = createTextLabel({ data: { text: 'hello' } });
+    expect(getTextLabelString(text)).toBe('hello');
+  });
+});
+
+describe('setTextLabelAutoSize', () => {
+  it('sets autoSize, bumps content, and invalidates local bounds', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    const bounds = getNodeLocalBoundsRevision(text);
+    setTextLabelAutoSize(text, 'left');
+    expect(text.data.autoSize).toBe('left');
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(text)).not.toBe(bounds);
+  });
+
+  it('does not bump content when the value is unchanged', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    setTextLabelAutoSize(text, 'none');
+    expect(getNodeLocalContentRevision(text)).toBe(content);
+  });
+});
+
+describe('setTextLabelFormat', () => {
+  it('sets the format and bumps content without touching bounds', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    const bounds = getNodeLocalBoundsRevision(text);
+    const format = { size: 24 };
+    setTextLabelFormat(text, format);
+    expect(text.data.textFormat).toBe(format);
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(text)).toBe(bounds);
+  });
+});
+
+describe('setTextLabelHeight', () => {
+  it('sets height, bumps content, and invalidates local bounds', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    const bounds = getNodeLocalBoundsRevision(text);
+    setTextLabelHeight(text, 250);
+    expect(text.data.height).toBe(250);
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(text)).not.toBe(bounds);
+  });
+
+  it('does not bump content when the value is unchanged', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    setTextLabelHeight(text, text.data.height);
+    expect(getNodeLocalContentRevision(text)).toBe(content);
+  });
+});
+
+describe('setTextLabelString', () => {
+  it('sets text and bumps content without touching bounds', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    const bounds = getNodeLocalBoundsRevision(text);
+    setTextLabelString(text, 'hello');
+    expect(text.data.text).toBe('hello');
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(text)).toBe(bounds);
+  });
+
+  it('does not bump content when the value is unchanged', () => {
+    const text = createTextLabel({ data: { text: 'same' } });
+    const content = getNodeLocalContentRevision(text);
+    setTextLabelString(text, 'same');
+    expect(getNodeLocalContentRevision(text)).toBe(content);
+  });
+});
+
+describe('setTextLabelWidth', () => {
+  it('sets width, bumps content, and invalidates local bounds', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    const bounds = getNodeLocalBoundsRevision(text);
+    setTextLabelWidth(text, 300);
+    expect(text.data.width).toBe(300);
+    expect(getNodeLocalContentRevision(text)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(text)).not.toBe(bounds);
+  });
+
+  it('does not bump content when the value is unchanged', () => {
+    const text = createTextLabel();
+    const content = getNodeLocalContentRevision(text);
+    setTextLabelWidth(text, text.data.width);
+    expect(getNodeLocalContentRevision(text)).toBe(content);
+  });
+});

package/src/textLabelLayout.test.ts

@@ -0,0 +1,78 @@
+import { createTextMetrics, setTextLayoutMeasureProvider } from '@flighthq/textlayout';
+
+import { createRichText, setRichTextString } from './richText';
+import { createTextLabel, setTextLabelString } from './textLabel';
+import { ensureTextLayout, getTextLayout, getTextLayoutMetrics } from './textLabelLayout';
+
+// A fake fixed-advance measure (7px per char) — exercises the ensure path without a renderer.
+const measure = (text: string) => text.length * 7;
+
+afterEach(() => {
+  setTextLayoutMeasureProvider(null);
+});
+
+describe('ensureTextLayout', () => {
+  it('leaves the layout null when no measure provider is registered', () => {
+    const richText = createRichText();
+    setRichTextString(richText, 'hello');
+    ensureTextLayout(richText);
+    expect(getTextLayout(richText)).toBeNull();
+  });
+
+  it('computes a layout for a RichText once a provider is registered', () => {
+    setTextLayoutMeasureProvider(measure);
+    const richText = createRichText();
+    setRichTextString(richText, 'hello');
+    ensureTextLayout(richText);
+    expect(getTextLayout(richText)).not.toBeNull();
+  });
+
+  it('computes a layout for a TextLabel via the shared single-run path', () => {
+    setTextLayoutMeasureProvider(measure);
+    const label = createTextLabel();
+    setTextLabelString(label, 'hi');
+    ensureTextLayout(label);
+    expect(getTextLayout(label)).not.toBeNull();
+  });
+});
+
+describe('getTextLayout', () => {
+  it('ensures the layout and returns it', () => {
+    setTextLayoutMeasureProvider(measure);
+    const richText = createRichText();
+    setRichTextString(richText, 'hi');
+    expect(getTextLayout(richText)).not.toBeNull();
+  });
+});
+
+describe('getTextLayoutMetrics', () => {
+  it('measures the content size for a RichText', () => {
+    setTextLayoutMeasureProvider(measure);
+    const richText = createRichText();
+    setRichTextString(richText, 'hello');
+    const out = createTextMetrics();
+    getTextLayoutMetrics(out, richText);
+    expect(out.width).toBeGreaterThan(0);
+    expect(out.numLines).toBeGreaterThanOrEqual(1);
+  });
+
+  it('measures the content size for a TextLabel', () => {
+    setTextLayoutMeasureProvider(measure);
+    const label = createTextLabel();
+    setTextLabelString(label, 'hello');
+    const out = createTextMetrics();
+    getTextLayoutMetrics(out, label);
+    expect(out.width).toBeGreaterThan(0);
+  });
+
+  it('zeroes the metrics when no provider is registered', () => {
+    const richText = createRichText();
+    setRichTextString(richText, 'hello');
+    const out = createTextMetrics();
+    out.width = 99;
+    getTextLayoutMetrics(out, richText);
+    expect(out.width).toBe(0);
+    expect(out.height).toBe(0);
+    expect(out.numLines).toBe(0);
+  });
+});