@flighthq/textlayout 0.1.0

package/src/richTextQuery.test.ts

@@ -0,0 +1,196 @@
+import type { TextLayoutResult, TextSelectionRectangle } from '@flighthq/types';
+
+import {
+  computeRichTextCharIndexAtPoint,
+  computeRichTextLineMetrics,
+  getRichTextCharBoundaries,
+  getRichTextFirstCharInParagraph,
+  getRichTextLineIndexAtPoint,
+  getRichTextLineIndexOfChar,
+  getRichTextLineLength,
+  getRichTextLineOffset,
+  getRichTextLineText,
+  getRichTextLinkAtPoint,
+  getRichTextParagraphLength,
+  getRichTextSelectionRectangles,
+} from './richTextQuery';
+
+// Two-line layout: 'abc' on line 0 (indices 0-3), 'defg' on line 1 (indices 3-7).
+function createLayout(): TextLayoutResult {
+  return {
+    groups: [
+      {
+        ascent: 10,
+        descent: 2,
+        endIndex: 3,
+        format: {},
+        height: 12,
+        leading: 0,
+        lineIndex: 0,
+        offsetX: 0,
+        offsetY: 2,
+        positions: [10, 10, 10],
+        startIndex: 0,
+        width: 30,
+      },
+      {
+        ascent: 10,
+        descent: 2,
+        endIndex: 7,
+        format: { url: 'https://example.com' },
+        height: 12,
+        leading: 0,
+        lineIndex: 1,
+        offsetX: 0,
+        offsetY: 16,
+        positions: [10, 10, 10, 10],
+        startIndex: 3,
+        width: 40,
+      },
+    ],
+    lineAscents: [10, 10],
+    lineDescents: [2, 2],
+    lineHeights: [14, 14],
+    lineLeadings: [0, 0],
+    lineWidths: [30, 40],
+    numLines: 2,
+    textHeight: 28,
+    textWidth: 40,
+  };
+}
+
+describe('computeRichTextCharIndexAtPoint', () => {
+  it('returns the index at a point within a group', () => {
+    expect(computeRichTextCharIndexAtPoint(createLayout(), 25, 5)).toBe(2);
+  });
+
+  it('selects the closest line by y distance', () => {
+    expect(computeRichTextCharIndexAtPoint(createLayout(), 5, 100)).toBe(7);
+  });
+});
+
+describe('computeRichTextLineMetrics', () => {
+  it('returns metrics for a valid line', () => {
+    const metrics = computeRichTextLineMetrics(createLayout(), 0);
+    expect(metrics).not.toBeNull();
+    expect(metrics!.ascent).toBe(10);
+    expect(metrics!.descent).toBe(2);
+    expect(metrics!.width).toBe(30);
+  });
+
+  it('returns null for a non-existent line', () => {
+    expect(computeRichTextLineMetrics(createLayout(), 5)).toBeNull();
+  });
+});
+
+describe('getRichTextCharBoundaries', () => {
+  it('fills out with the bounding box of the character', () => {
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    const found = getRichTextCharBoundaries(out as never, createLayout(), 1);
+    expect(found).toBe(true);
+    expect(out.x).toBe(10);
+    expect(out.y).toBe(2);
+    expect(out.width).toBe(10);
+    expect(out.height).toBe(12);
+  });
+
+  it('returns false for an out-of-range index', () => {
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    expect(getRichTextCharBoundaries(out as never, createLayout(), 99)).toBe(false);
+  });
+});
+
+describe('getRichTextFirstCharInParagraph', () => {
+  it('returns 0 at the start of the first paragraph', () => {
+    expect(getRichTextFirstCharInParagraph('hello\nworld', 3)).toBe(0);
+  });
+
+  it('returns the position after the newline for a later paragraph', () => {
+    expect(getRichTextFirstCharInParagraph('hello\nworld', 8)).toBe(6);
+  });
+});
+
+describe('getRichTextLineIndexAtPoint', () => {
+  it('returns 0 for a y value within the first line', () => {
+    expect(getRichTextLineIndexAtPoint(createLayout(), 5)).toBe(0);
+  });
+
+  it('returns 1 for a y value within the second line', () => {
+    expect(getRichTextLineIndexAtPoint(createLayout(), 18)).toBe(1);
+  });
+});
+
+describe('getRichTextLineIndexOfChar', () => {
+  it('returns 0 for a character on the first line', () => {
+    expect(getRichTextLineIndexOfChar(createLayout(), 1)).toBe(0);
+  });
+
+  it('returns 1 for a character on the second line', () => {
+    expect(getRichTextLineIndexOfChar(createLayout(), 5)).toBe(1);
+  });
+});
+
+describe('getRichTextLineLength', () => {
+  it('returns the character count of the requested line', () => {
+    expect(getRichTextLineLength(createLayout(), 0)).toBe(3);
+    expect(getRichTextLineLength(createLayout(), 1)).toBe(4);
+  });
+
+  it('returns 0 for a non-existent line', () => {
+    expect(getRichTextLineLength(createLayout(), 5)).toBe(0);
+  });
+});
+
+describe('getRichTextLineOffset', () => {
+  it('returns the start index of the requested line', () => {
+    expect(getRichTextLineOffset(createLayout(), 0)).toBe(0);
+    expect(getRichTextLineOffset(createLayout(), 1)).toBe(3);
+  });
+});
+
+describe('getRichTextLineText', () => {
+  it('returns the text slice for the requested line', () => {
+    expect(getRichTextLineText('abcdefg', createLayout(), 0)).toBe('abc');
+    expect(getRichTextLineText('abcdefg', createLayout(), 1)).toBe('defg');
+  });
+
+  it('returns empty string for a non-existent line', () => {
+    expect(getRichTextLineText('abcdefg', createLayout(), 5)).toBe('');
+  });
+});
+
+describe('getRichTextLinkAtPoint', () => {
+  it('returns the url when the point hits a group with a url', () => {
+    expect(getRichTextLinkAtPoint(createLayout(), 10, 18)).toBe('https://example.com');
+  });
+
+  it('returns null when the point does not hit a linked group', () => {
+    expect(getRichTextLinkAtPoint(createLayout(), 10, 5)).toBeNull();
+  });
+});
+
+describe('getRichTextParagraphLength', () => {
+  it('returns the length including the newline', () => {
+    expect(getRichTextParagraphLength('hello\nworld', 3)).toBe(6);
+  });
+
+  it('returns to end of string when there is no trailing newline', () => {
+    expect(getRichTextParagraphLength('hello\nworld', 8)).toBe(5);
+  });
+});
+
+describe('getRichTextSelectionRectangles', () => {
+  it('fills out with one rectangle per intersected group', () => {
+    const out: TextSelectionRectangle[] = [];
+    getRichTextSelectionRectangles(out, 1, 5, createLayout());
+    expect(out).toHaveLength(2);
+    expect(out[0].lineIndex).toBe(0);
+    expect(out[1].lineIndex).toBe(1);
+  });
+
+  it('returns empty for a collapsed selection', () => {
+    const out: TextSelectionRectangle[] = [];
+    getRichTextSelectionRectangles(out, 2, 2, createLayout());
+    expect(out).toHaveLength(0);
+  });
+});

package/src/textBounds.test.ts

@@ -0,0 +1,110 @@
+import type { RectangleLike, TextLayoutResult } from '@flighthq/types';
+
+import type { TextBoundsSpec } from './textBounds';
+import {
+  computeTextBoundsHeight,
+  computeTextBoundsOffsetX,
+  computeTextBoundsRectangle,
+  computeTextBoundsWidth,
+  TEXT_BOUNDS_GUTTER,
+} from './textBounds';
+import { TEXT_LAYOUT_GUTTER } from './textLayout';
+
+function createSpec(spec: Partial<TextBoundsSpec> = {}): TextBoundsSpec {
+  return {
+    autoSize: 'none',
+    height: 100,
+    width: 200,
+    wordWrap: false,
+    ...spec,
+  };
+}
+
+function createLayout(layout: Partial<TextLayoutResult> = {}): TextLayoutResult {
+  return {
+    groups: [],
+    lineAscents: [],
+    lineDescents: [],
+    lineHeights: [],
+    lineLeadings: [],
+    lineWidths: [],
+    numLines: 1,
+    textHeight: 20,
+    textWidth: 50,
+    ...layout,
+  };
+}
+
+describe('computeTextBoundsHeight', () => {
+  it('uses spec height when autoSize is none', () => {
+    expect(computeTextBoundsHeight(createSpec({ autoSize: 'none', height: 80 }), createLayout())).toBe(80);
+  });
+
+  it('uses text height plus gutters when autoSize is enabled', () => {
+    expect(computeTextBoundsHeight(createSpec({ autoSize: 'left' }), createLayout({ textHeight: 18 }))).toBe(22);
+  });
+});
+
+describe('computeTextBoundsOffsetX', () => {
+  it('returns zero for left and none anchoring', () => {
+    expect(
+      computeTextBoundsOffsetX(createSpec({ autoSize: 'left', width: 120 }), createLayout({ textWidth: 30 })),
+    ).toBe(0);
+  });
+
+  it('shifts the box fully into the slack for right anchoring', () => {
+    expect(
+      computeTextBoundsOffsetX(createSpec({ autoSize: 'right', width: 120 }), createLayout({ textWidth: 30 })),
+    ).toBe(86);
+  });
+
+  it('splits the slack for center anchoring', () => {
+    expect(
+      computeTextBoundsOffsetX(createSpec({ autoSize: 'center', width: 120 }), createLayout({ textWidth: 30 })),
+    ).toBe(43);
+  });
+});
+
+describe('computeTextBoundsRectangle', () => {
+  it('fills the declared box at the origin when autoSize is none', () => {
+    const out: RectangleLike = { height: 0, width: 0, x: 0, y: 0 };
+    computeTextBoundsRectangle(out, createSpec({ autoSize: 'none', width: 120, height: 80 }), createLayout());
+    expect(out).toEqual({ height: 80, width: 120, x: 0, y: 0 });
+  });
+
+  it('fills the measured box with the anchor offset under autoSize', () => {
+    const out: RectangleLike = { height: 0, width: 0, x: 0, y: 0 };
+    computeTextBoundsRectangle(
+      out,
+      createSpec({ autoSize: 'right', width: 120 }),
+      createLayout({ textWidth: 30, textHeight: 18 }),
+    );
+    expect(out).toEqual({ height: 22, width: 34, x: 86, y: 0 });
+  });
+});
+
+describe('computeTextBoundsWidth', () => {
+  it('uses spec width when autoSize is none', () => {
+    expect(computeTextBoundsWidth(createSpec({ autoSize: 'none', width: 120 }), createLayout())).toBe(120);
+  });
+
+  it('uses spec width when wordWrap is enabled', () => {
+    expect(computeTextBoundsWidth(createSpec({ autoSize: 'left', width: 120, wordWrap: true }), createLayout())).toBe(
+      120,
+    );
+  });
+
+  it('uses text width plus gutters when autoSize is enabled', () => {
+    expect(computeTextBoundsWidth(createSpec({ autoSize: 'left' }), createLayout({ textWidth: 30 }))).toBe(34);
+  });
+});
+
+describe('TEXT_BOUNDS_GUTTER', () => {
+  it('equals TEXT_LAYOUT_GUTTER (de-duplicated constant)', () => {
+    expect(TEXT_BOUNDS_GUTTER).toBe(TEXT_LAYOUT_GUTTER);
+  });
+
+  it('is a positive number', () => {
+    expect(TEXT_BOUNDS_GUTTER).toBeGreaterThan(0);
+  });
+});

package/src/textFormat.test.ts

@@ -0,0 +1,66 @@
+import {
+  getTextFormatAscent,
+  getTextFormatDescent,
+  getTextFormatHeight,
+  getTextFormatLeading,
+  mergeTextFormat,
+} from './textFormat';
+
+describe('getTextFormatAscent', () => {
+  it('returns size when specified', () => {
+    expect(getTextFormatAscent({ size: 24 })).toBe(24);
+  });
+
+  it('returns 12 when size is absent', () => {
+    expect(getTextFormatAscent({})).toBe(12);
+  });
+});
+
+describe('getTextFormatDescent', () => {
+  it('returns 18.5% of size', () => {
+    expect(getTextFormatDescent({ size: 100 })).toBeCloseTo(18.5);
+  });
+
+  it('uses default size of 12 when absent', () => {
+    expect(getTextFormatDescent({})).toBeCloseTo(12 * 0.185);
+  });
+});
+
+describe('getTextFormatHeight', () => {
+  it('sums ascent, descent and leading', () => {
+    expect(getTextFormatHeight({ size: 10, leading: 4 })).toBeCloseTo(10 + 10 * 0.185 + 4);
+  });
+
+  it('treats absent leading as zero', () => {
+    expect(getTextFormatHeight({ size: 10 })).toBeCloseTo(10 + 10 * 0.185);
+  });
+});
+
+describe('getTextFormatLeading', () => {
+  it('returns leading when specified', () => {
+    expect(getTextFormatLeading({ leading: 6 })).toBe(6);
+  });
+
+  it('returns 0 when absent', () => {
+    expect(getTextFormatLeading({})).toBe(0);
+  });
+});
+
+describe('mergeTextFormat', () => {
+  it('applies non-null override fields onto base', () => {
+    const result = mergeTextFormat({ size: 12, bold: false }, { bold: true, color: 0xff0000 });
+    expect(result).toMatchObject({ size: 12, bold: true, color: 0xff0000 });
+  });
+
+  it('skips null and undefined override fields', () => {
+    const result = mergeTextFormat({ size: 12 }, { size: undefined, bold: undefined });
+    expect(result.size).toBe(12);
+    expect(result.bold).toBeUndefined();
+  });
+
+  it('does not mutate the base object', () => {
+    const base = { size: 12 };
+    mergeTextFormat(base, { size: 24 });
+    expect(base.size).toBe(12);
+  });
+});

package/src/textFormatRange.test.ts

@@ -0,0 +1,9 @@
+import { createTextFormatRange } from './textFormatRange';
+
+describe('createTextFormatRange', () => {
+  it('creates a range with the given fields', () => {
+    const fmt = { size: 16, bold: true };
+    const range = createTextFormatRange(fmt, 0, 10);
+    expect(range).toEqual({ format: fmt, start: 0, end: 10 });
+  });
+});