expo-pretext 0.2.0

package/src/__tests__/font-utils.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from 'bun:test'
+import {
+  textStyleToFontDescriptor,
+  getFontKey,
+  getLineHeight,
+} from '../font-utils'
+import type { TextStyle } from '../types'
+
+describe('font-utils', () => {
+  const baseStyle: TextStyle = {
+    fontFamily: 'Inter',
+    fontSize: 16,
+    lineHeight: 24,
+    fontWeight: '700',
+    fontStyle: 'italic',
+  }
+
+  describe('textStyleToFontDescriptor', () => {
+    test('converts full style', () => {
+      const desc = textStyleToFontDescriptor(baseStyle)
+      expect(desc).toEqual({
+        fontFamily: 'Inter',
+        fontSize: 16,
+        fontWeight: '700',
+        fontStyle: 'italic',
+      })
+    })
+
+    test('handles minimal style', () => {
+      const desc = textStyleToFontDescriptor({ fontFamily: 'Arial', fontSize: 14 })
+      expect(desc).toEqual({
+        fontFamily: 'Arial',
+        fontSize: 14,
+        fontWeight: undefined,
+        fontStyle: undefined,
+      })
+    })
+  })
+
+  describe('getFontKey', () => {
+    test('full style produces correct key', () => {
+      expect(getFontKey(baseStyle)).toBe('Inter_16_700_italic')
+    })
+
+    test('minimal style uses defaults', () => {
+      expect(getFontKey({ fontFamily: 'Arial', fontSize: 14 })).toBe('Arial_14_400_normal')
+    })
+
+    test('different weights produce different keys', () => {
+      const light = getFontKey({ fontFamily: 'Inter', fontSize: 16, fontWeight: '400' })
+      const bold = getFontKey({ fontFamily: 'Inter', fontSize: 16, fontWeight: '700' })
+      expect(light).not.toBe(bold)
+    })
+  })
+
+  describe('getLineHeight', () => {
+    test('returns explicit lineHeight', () => {
+      expect(getLineHeight(baseStyle)).toBe(24)
+    })
+
+    test('falls back to fontSize * 1.2', () => {
+      expect(getLineHeight({ fontFamily: 'Inter', fontSize: 20 })).toBe(24)
+    })
+
+    test('falls back correctly for small font', () => {
+      expect(getLineHeight({ fontFamily: 'Inter', fontSize: 10 })).toBe(12)
+    })
+  })
+})

package/src/__tests__/layout.test.ts

@@ -0,0 +1,300 @@
+// layout.test.ts
+// Tests for the core layout engine: layout(), layoutWithLines(),
+// walkLineRanges(), measureNaturalWidth(), and the prepare() fallback path.
+//
+// We bypass prepare.ts (which imports ExpoPretext → expo-modules-core →
+// react-native) and instead directly wire the same estimateSegments fallback
+// that prepare() uses when the native module is unavailable.
+
+import { describe, test, expect } from 'bun:test'
+import { buildPreparedText, buildPreparedTextWithSegments } from '../build'
+import {
+  layout,
+  layoutWithLines,
+  walkLineRanges,
+  measureNaturalWidth,
+} from '../layout'
+import { analyzeText } from '../analysis'
+import type { TextStyle, NativeSegmentResult } from '../types'
+
+const STYLE: TextStyle = { fontFamily: 'System', fontSize: 16, lineHeight: 24 }
+
+// ---------------------------------------------------------------------------
+// Helpers — mirrors prepare.ts's fallback when native module is unavailable
+// ---------------------------------------------------------------------------
+
+// Same logic as estimateSegments() in prepare.ts
+function estimateSegments(text: string, style: TextStyle): NativeSegmentResult {
+  const words = text.split(/(\s+)/)
+  const charWidth = style.fontSize * 0.55
+  return {
+    segments: words,
+    isWordLike: words.map(w => !/^\s+$/.test(w)),
+    widths: words.map(w => w.length * charWidth),
+  }
+}
+
+function buildWidthMap(result: NativeSegmentResult): Map<string, number> {
+  const map = new Map<string, number>()
+  for (let i = 0; i < result.segments.length; i++) {
+    map.set(result.segments[i]!, result.widths[i]!)
+  }
+  return map
+}
+
+function makePrepared(text: string, style: TextStyle = STYLE) {
+  if (!text) {
+    const analysis = analyzeText([], [], {}, undefined)
+    return buildPreparedText(analysis, new Map(), style)
+  }
+  const result = estimateSegments(text, style)
+  const analysis = analyzeText(result.segments, result.isWordLike, {}, undefined)
+  return buildPreparedText(analysis, buildWidthMap(result), style)
+}
+
+function makePreparedWithSegments(text: string, style: TextStyle = STYLE) {
+  if (!text) {
+    const analysis = analyzeText([], [], {}, undefined)
+    return buildPreparedTextWithSegments(analysis, new Map(), style)
+  }
+  const result = estimateSegments(text, style)
+  const analysis = analyzeText(result.segments, result.isWordLike, {}, undefined)
+  return buildPreparedTextWithSegments(analysis, buildWidthMap(result), style)
+}
+
+// ---------------------------------------------------------------------------
+// layout() basics
+// ---------------------------------------------------------------------------
+
+describe('layout() basics', () => {
+  test('empty string returns height = 0 and lineCount = 0', () => {
+    const p = makePrepared('')
+    const result = layout(p, 300)
+    expect(result.height).toBe(0)
+    expect(result.lineCount).toBe(0)
+  })
+
+  test('single short word: 1 line, height = lineHeight', () => {
+    // "Hello" = 5 chars * 8.8px = 44px → fits in 300px → 1 line
+    const p = makePrepared('Hello')
+    const result = layout(p, 300)
+    expect(result.lineCount).toBe(1)
+    expect(result.height).toBe(24)
+  })
+
+  test('text that wraps at narrow width: lineCount > 1', () => {
+    // "Hello World Test" = 16 chars * 8.8px = 140.8px → wraps at 100px
+    const p = makePrepared('Hello World Test')
+    const result = layout(p, 100)
+    expect(result.lineCount).toBeGreaterThan(1)
+    expect(result.height).toBeGreaterThan(24)
+  })
+
+  test('wider maxWidth produces fewer or equal lines and less or equal height', () => {
+    const p = makePrepared('Hello World Test')
+    const narrow = layout(p, 100)
+    const wide = layout(p, 300)
+    expect(wide.lineCount).toBeLessThanOrEqual(narrow.lineCount)
+    expect(wide.height).toBeLessThanOrEqual(narrow.height)
+  })
+
+  test('height equals lineCount * lineHeight', () => {
+    const p = makePrepared('Hello World Test Long Line')
+    const result = layout(p, 100)
+    expect(result.height).toBe(result.lineCount * STYLE.lineHeight!)
+  })
+
+  test('zero width handled gracefully — does not throw', () => {
+    const p = makePrepared('Hello')
+    expect(() => layout(p, 0)).not.toThrow()
+  })
+
+  test('negative width handled gracefully — does not throw', () => {
+    const p = makePrepared('Hello')
+    expect(() => layout(p, -100)).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// layoutWithLines()
+// ---------------------------------------------------------------------------
+
+describe('layoutWithLines()', () => {
+  test('empty string returns empty lines array, height = 0', () => {
+    const p = makePreparedWithSegments('')
+    const result = layoutWithLines(p, 300)
+    expect(result.lines).toEqual([])
+    expect(result.lineCount).toBe(0)
+    expect(result.height).toBe(0)
+  })
+
+  test('single word: 1 line with text', () => {
+    const p = makePreparedWithSegments('Hello')
+    const result = layoutWithLines(p, 300)
+    expect(result.lines.length).toBe(1)
+    expect(typeof result.lines[0]!.text).toBe('string')
+    expect(result.lines[0]!.text.length).toBeGreaterThan(0)
+  })
+
+  test('returns lines with start/end cursor objects', () => {
+    const p = makePreparedWithSegments('Hello')
+    const result = layoutWithLines(p, 300)
+    const line = result.lines[0]!
+    expect(line).toHaveProperty('start')
+    expect(line).toHaveProperty('end')
+    expect(line.start).toHaveProperty('segmentIndex')
+    expect(line.start).toHaveProperty('graphemeIndex')
+    expect(line.end).toHaveProperty('segmentIndex')
+    expect(line.end).toHaveProperty('graphemeIndex')
+  })
+
+  test('lineCount matches lines.length', () => {
+    const p = makePreparedWithSegments('Hello World Test')
+    const result = layoutWithLines(p, 100)
+    expect(result.lineCount).toBe(result.lines.length)
+  })
+
+  test('height matches layout() result', () => {
+    const text = 'Hello World Test'
+    const p1 = makePrepared(text)
+    const p2 = makePreparedWithSegments(text)
+    const r1 = layout(p1, 100)
+    const r2 = layoutWithLines(p2, 100)
+    expect(r2.height).toBe(r1.height)
+    expect(r2.lineCount).toBe(r1.lineCount)
+  })
+
+  test('each line has a non-negative width', () => {
+    const p = makePreparedWithSegments('Hello World Test')
+    const result = layoutWithLines(p, 100)
+    for (const line of result.lines) {
+      expect(line.width).toBeGreaterThanOrEqual(0)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// walkLineRanges()
+// ---------------------------------------------------------------------------
+
+describe('walkLineRanges()', () => {
+  test('empty string: callback never called, returns 0', () => {
+    const p = makePreparedWithSegments('')
+    let calls = 0
+    const total = walkLineRanges(p, 300, () => { calls++ })
+    expect(calls).toBe(0)
+    expect(total).toBe(0)
+  })
+
+  test('callback called once per line', () => {
+    const p = makePreparedWithSegments('Hello World Test')
+    const p2 = makePrepared('Hello World Test')
+    const lines: unknown[] = []
+    walkLineRanges(p, 100, line => lines.push(line))
+    const { lineCount } = layout(p2, 100)
+    expect(lines.length).toBe(lineCount)
+  })
+
+  test('each line range has start, end, and width properties', () => {
+    const p = makePreparedWithSegments('Hello World')
+    walkLineRanges(p, 300, line => {
+      expect(line).toHaveProperty('start')
+      expect(line).toHaveProperty('end')
+      expect(line).toHaveProperty('width')
+      expect(line.width).toBeGreaterThanOrEqual(0)
+    })
+  })
+
+  test('total callback count matches layout() lineCount', () => {
+    const text = 'Hello World Test Long String'
+    const p = makePreparedWithSegments(text)
+    const p2 = makePrepared(text)
+    let count = 0
+    walkLineRanges(p, 100, () => { count++ })
+    expect(count).toBe(layout(p2, 100).lineCount)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// measureNaturalWidth()
+// ---------------------------------------------------------------------------
+
+describe('measureNaturalWidth()', () => {
+  test('returns 0 for empty string', () => {
+    const p = makePreparedWithSegments('')
+    expect(measureNaturalWidth(p)).toBe(0)
+  })
+
+  test('returns positive number for non-empty text', () => {
+    const p = makePreparedWithSegments('Hello')
+    expect(measureNaturalWidth(p)).toBeGreaterThan(0)
+  })
+
+  test('"Hello" (5 chars * 8.8px) natural width ≈ 44px — within reasonable bounds', () => {
+    const p = makePreparedWithSegments('Hello')
+    const w = measureNaturalWidth(p)
+    // estimator: 5 * 8.8 = 44
+    expect(w).toBeGreaterThan(0)
+    expect(w).toBeLessThan(200)
+  })
+
+  test('longer single-word text has greater natural width than shorter', () => {
+    const short = makePreparedWithSegments('Hi')
+    const long = makePreparedWithSegments('Hello')
+    expect(measureNaturalWidth(long)).toBeGreaterThan(measureNaturalWidth(short))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// prepare() fallback path — edge cases via estimateSegments
+// ---------------------------------------------------------------------------
+
+describe('prepare() fallback edge cases', () => {
+  test('empty string — height = 0', () => {
+    const p = makePrepared('')
+    expect(layout(p, 300).height).toBe(0)
+  })
+
+  test('single character — 1 line', () => {
+    const p = makePrepared('A')
+    const result = layout(p, 300)
+    expect(result.lineCount).toBe(1)
+    expect(result.height).toBe(24)
+  })
+
+  test('very long string — wraps into multiple lines', () => {
+    const long = 'abcdefghij '.repeat(30)
+    const p = makePrepared(long)
+    const result = layout(p, 300)
+    expect(result.lineCount).toBeGreaterThan(1)
+    expect(result.height).toBeGreaterThan(24)
+  })
+
+  test('CJK characters — does not throw, returns at least 1 line', () => {
+    expect(() => makePrepared('你好世界')).not.toThrow()
+    const p = makePrepared('你好世界')
+    expect(layout(p, 300).lineCount).toBeGreaterThanOrEqual(1)
+  })
+
+  test('emoji — does not throw, returns at least 1 line', () => {
+    expect(() => makePrepared('🎉🎊🎈')).not.toThrow()
+    const p = makePrepared('🎉🎊🎈')
+    expect(layout(p, 300).lineCount).toBeGreaterThanOrEqual(1)
+  })
+
+  test('mixed scripts (Latin + CJK + emoji) — does not throw, positive height', () => {
+    const mixed = 'Hello 你好 World 🎉'
+    expect(() => makePrepared(mixed)).not.toThrow()
+    const p = makePrepared(mixed)
+    const result = layout(p, 300)
+    expect(result.lineCount).toBeGreaterThanOrEqual(1)
+    expect(result.height).toBeGreaterThan(0)
+  })
+
+  test('Unicode RTL text — does not throw', () => {
+    const arabic = 'مرحبا بالعالم'
+    expect(() => makePrepared(arabic)).not.toThrow()
+    const p = makePrepared(arabic)
+    expect(layout(p, 300).lineCount).toBeGreaterThanOrEqual(1)
+  })
+})

package/src/__tests__/obstacle-layout.test.ts

@@ -0,0 +1,127 @@
+import { describe, test, expect } from 'bun:test'
+import {
+  carveTextLineSlots,
+  circleIntervalForBand,
+  rectIntervalForBand,
+} from '../obstacle-layout'
+
+describe('circleIntervalForBand', () => {
+  test('returns null when band is above circle', () => {
+    expect(circleIntervalForBand(100, 100, 30, 0, 20)).toBeNull()
+  })
+
+  test('returns null when band is below circle', () => {
+    expect(circleIntervalForBand(100, 100, 30, 140, 160)).toBeNull()
+  })
+
+  test('returns interval when band intersects circle center', () => {
+    const iv = circleIntervalForBand(100, 100, 50, 90, 110)
+    expect(iv).not.toBeNull()
+    expect(iv!.left).toBeLessThan(100)
+    expect(iv!.right).toBeGreaterThan(100)
+    // At center, chord width = 2 * radius
+    expect(iv!.right - iv!.left).toBeCloseTo(100, 0)
+  })
+
+  test('returns narrower interval when band is near edge', () => {
+    const center = circleIntervalForBand(100, 100, 50, 95, 105)
+    const edge = circleIntervalForBand(100, 100, 50, 140, 150)
+    expect(center).not.toBeNull()
+    expect(edge).not.toBeNull()
+    expect(center!.right - center!.left).toBeGreaterThan(edge!.right - edge!.left)
+  })
+
+  test('respects hPad', () => {
+    const without = circleIntervalForBand(100, 100, 50, 95, 105, 0, 0)
+    const withPad = circleIntervalForBand(100, 100, 50, 95, 105, 10, 0)
+    expect(withPad!.left).toBeLessThan(without!.left)
+    expect(withPad!.right).toBeGreaterThan(without!.right)
+    expect((withPad!.right - withPad!.left) - (without!.right - without!.left)).toBeCloseTo(20, 0)
+  })
+})
+
+describe('rectIntervalForBand', () => {
+  test('returns null when band is above rect', () => {
+    expect(rectIntervalForBand({ x: 50, y: 100, w: 80, h: 40 }, 0, 20)).toBeNull()
+  })
+
+  test('returns null when band is below rect', () => {
+    expect(rectIntervalForBand({ x: 50, y: 100, w: 80, h: 40 }, 150, 170)).toBeNull()
+  })
+
+  test('returns interval when band intersects rect', () => {
+    const iv = rectIntervalForBand({ x: 50, y: 100, w: 80, h: 40 }, 110, 130)
+    expect(iv).not.toBeNull()
+    expect(iv!.left).toBe(50)
+    expect(iv!.right).toBe(130)
+  })
+})
+
+describe('carveTextLineSlots', () => {
+  test('returns full base when no obstacles', () => {
+    const slots = carveTextLineSlots({ left: 0, right: 300 }, [])
+    expect(slots).toEqual([{ left: 0, right: 300 }])
+  })
+
+  test('splits base around one obstacle', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 300 },
+      [{ left: 100, right: 200 }]
+    )
+    expect(slots.length).toBe(2)
+    expect(slots[0]).toEqual({ left: 0, right: 100 })
+    expect(slots[1]).toEqual({ left: 200, right: 300 })
+  })
+
+  test('filters slots narrower than minSlotWidth', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 300 },
+      [{ left: 10, right: 290 }],
+      30
+    )
+    expect(slots.length).toBe(0) // both remaining slots < 30px
+  })
+
+  test('handles obstacle at left edge', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 300 },
+      [{ left: -10, right: 80 }]
+    )
+    expect(slots.length).toBe(1)
+    expect(slots[0]!.left).toBe(80)
+    expect(slots[0]!.right).toBe(300)
+  })
+
+  test('handles obstacle at right edge', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 300 },
+      [{ left: 250, right: 350 }]
+    )
+    expect(slots.length).toBe(1)
+    expect(slots[0]!.left).toBe(0)
+    expect(slots[0]!.right).toBe(250)
+  })
+
+  test('handles multiple obstacles', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 400 },
+      [{ left: 50, right: 100 }, { left: 200, right: 280 }]
+    )
+    expect(slots.length).toBe(3)
+    expect(slots[0]).toEqual({ left: 0, right: 50 })
+    expect(slots[1]).toEqual({ left: 100, right: 200 })
+    expect(slots[2]).toEqual({ left: 280, right: 400 })
+  })
+
+  test('handles overlapping obstacles', () => {
+    const slots = carveTextLineSlots(
+      { left: 0, right: 300 },
+      [{ left: 80, right: 150 }, { left: 120, right: 200 }]
+    )
+    // After first: [0,80] [150,300]
+    // After second removes from [150,300]: [200,300]
+    expect(slots.length).toBe(2)
+    expect(slots[0]).toEqual({ left: 0, right: 80 })
+    expect(slots[1]).toEqual({ left: 200, right: 300 })
+  })
+})

package/src/__tests__/setup-mocks.ts

@@ -0,0 +1,14 @@
+// Test environment setup: mock native dependencies so the layout
+// engine tests can run in bun without a React Native runtime.
+import { mock } from 'bun:test'
+
+mock.module('react-native', () => ({
+  Platform: { OS: 'ios', select: (obj: Record<string, unknown>) => obj.ios ?? obj.default },
+  NativeModules: {},
+  NativeEventEmitter: class {},
+}))
+
+mock.module('expo-modules-core', () => ({
+  NativeModule: class {},
+  requireNativeModule: () => null,
+}))