expo-pretext 0.2.0

package/src/bidi.ts

@@ -0,0 +1,175 @@
+// Simplified bidi metadata helper for the rich prepareWithSegments() path,
+// forked from pdf.js via Sebastian's text-layout. It classifies characters
+// into bidi types, computes embedding levels, and maps them onto prepared
+// segments for custom rendering. The line-breaking engine does not consume
+// these levels.
+
+import {
+  latin1BidiTypes,
+  nonLatin1BidiRanges,
+  type GeneratedBidiType as BidiType,
+} from './generated/bidi-data'
+
+function classifyCodePoint(codePoint: number): BidiType {
+  if (codePoint <= 0x00FF) return latin1BidiTypes[codePoint]!
+
+  let lo = 0
+  let hi = nonLatin1BidiRanges.length - 1
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1
+    const range = nonLatin1BidiRanges[mid]!
+    if (codePoint < range[0]) {
+      hi = mid - 1
+      continue
+    }
+    if (codePoint > range[1]) {
+      lo = mid + 1
+      continue
+    }
+    return range[2]
+  }
+
+  return 'L'
+}
+
+function computeBidiLevels(str: string): Int8Array | null {
+  const len = str.length
+  if (len === 0) return null
+
+  // eslint-disable-next-line unicorn/no-new-array
+  const types: BidiType[] = new Array(len)
+  let sawBidi = false
+
+  // Keep the resolved bidi classes aligned to UTF-16 code-unit offsets,
+  // because the rich prepared segments index back into the normalized string
+  // with JavaScript string offsets.
+  for (let i = 0; i < len;) {
+    const first = str.charCodeAt(i)
+    let codePoint = first
+    let codeUnitLength = 1
+
+    if (first >= 0xD800 && first <= 0xDBFF && i + 1 < len) {
+      const second = str.charCodeAt(i + 1)
+      if (second >= 0xDC00 && second <= 0xDFFF) {
+        codePoint = ((first - 0xD800) << 10) + (second - 0xDC00) + 0x10000
+        codeUnitLength = 2
+      }
+    }
+
+    const t = classifyCodePoint(codePoint)
+    if (t === 'R' || t === 'AL' || t === 'AN') sawBidi = true
+    for (let j = 0; j < codeUnitLength; j++) {
+      types[i + j] = t
+    }
+    i += codeUnitLength
+  }
+
+  if (!sawBidi) return null
+
+  // Use the first strong character to pick the paragraph base direction.
+  // Rich-path bidi metadata is only an approximation, but this keeps mixed
+  // LTR/RTL text aligned with the common UBA paragraph rule.
+  let startLevel = 0
+  for (let i = 0; i < len; i++) {
+    const t = types[i]!
+    if (t === 'L') {
+      startLevel = 0
+      break
+    }
+    if (t === 'R' || t === 'AL') {
+      startLevel = 1
+      break
+    }
+  }
+  const levels = new Int8Array(len)
+  for (let i = 0; i < len; i++) levels[i] = startLevel
+
+  const e: BidiType = (startLevel & 1) ? 'R' : 'L'
+  const sor = e
+
+  // W1-W7
+  let lastType: BidiType = sor
+  for (let i = 0; i < len; i++) {
+    if (types[i] === 'NSM') types[i] = lastType
+    else lastType = types[i]!
+  }
+  lastType = sor
+  for (let i = 0; i < len; i++) {
+    const t = types[i]!
+    if (t === 'EN') types[i] = lastType === 'AL' ? 'AN' : 'EN'
+    else if (t === 'R' || t === 'L' || t === 'AL') lastType = t
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] === 'AL') types[i] = 'R'
+  }
+  for (let i = 1; i < len - 1; i++) {
+    if (types[i] === 'ES' && types[i - 1] === 'EN' && types[i + 1] === 'EN') {
+      types[i] = 'EN'
+    }
+    if (
+      types[i] === 'CS' &&
+      (types[i - 1] === 'EN' || types[i - 1] === 'AN') &&
+      types[i + 1] === types[i - 1]
+    ) {
+      types[i] = types[i - 1]!
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] !== 'EN') continue
+    let j
+    for (j = i - 1; j >= 0 && types[j] === 'ET'; j--) types[j] = 'EN'
+    for (j = i + 1; j < len && types[j] === 'ET'; j++) types[j] = 'EN'
+  }
+  for (let i = 0; i < len; i++) {
+    const t = types[i]!
+    if (t === 'WS' || t === 'ES' || t === 'ET' || t === 'CS') types[i] = 'ON'
+  }
+  lastType = sor
+  for (let i = 0; i < len; i++) {
+    const t = types[i]!
+    if (t === 'EN') types[i] = lastType === 'L' ? 'L' : 'EN'
+    else if (t === 'R' || t === 'L') lastType = t
+  }
+
+  // N1-N2
+  for (let i = 0; i < len; i++) {
+    if (types[i] !== 'ON') continue
+    let end = i + 1
+    while (end < len && types[end] === 'ON') end++
+    const before: BidiType = i > 0 ? types[i - 1]! : sor
+    const after: BidiType = end < len ? types[end]! : sor
+    const bDir: BidiType = before !== 'L' ? 'R' : 'L'
+    const aDir: BidiType = after !== 'L' ? 'R' : 'L'
+    if (bDir === aDir) {
+      for (let j = i; j < end; j++) types[j] = bDir
+    }
+    i = end - 1
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] === 'ON') types[i] = e
+  }
+
+  // I1-I2
+  for (let i = 0; i < len; i++) {
+    const t = types[i]!
+    if ((levels[i]! & 1) === 0) {
+      if (t === 'R') levels[i]!++
+      else if (t === 'AN' || t === 'EN') levels[i]! += 2
+    } else if (t === 'L' || t === 'AN' || t === 'EN') {
+      levels[i]!++
+    }
+  }
+
+  return levels
+}
+
+export function computeSegmentLevels(normalized: string, segStarts: number[]): Int8Array | null {
+  const bidiLevels = computeBidiLevels(normalized)
+  if (bidiLevels === null) return null
+
+  const segLevels = new Int8Array(segStarts.length)
+  for (let i = 0; i < segStarts.length; i++) {
+    segLevels[i] = bidiLevels[segStarts[i]!]!
+  }
+  return segLevels
+}

package/src/build.ts

@@ -0,0 +1,503 @@
+// Build prepared text handles from pre-analyzed + pre-measured data.
+// Extracted from layout.ts — contains the factory logic that constructs
+// the internal PreparedText structures consumed by the line-breaking engine.
+
+import { computeSegmentLevels } from './bidi'
+import {
+  canContinueKeepAllTextRun,
+  endsWithClosingQuote,
+  isCJK,
+  isNumericRunSegment,
+  kinsokuEnd,
+  kinsokuStart,
+  leftStickyPunctuation,
+  type AnalysisChunk,
+  type SegmentBreakKind,
+  type TextAnalysis,
+  type WhiteSpaceMode,
+  type WordBreakMode,
+} from './analysis'
+import { getEngineProfile } from './engine-profile'
+import type {
+  TextStyle,
+  PreparedText,
+  PreparedTextWithSegments as PublicPreparedTextWithSegments,
+} from './types'
+
+// --- Grapheme segmenter ---
+// Intl.Segmenter may not be available in Hermes — use a fallback
+// that splits on Unicode code points via spread operator.
+
+export interface GraphemeSegmenterLike {
+  segment(text: string): Iterable<{ segment: string; index: number }>
+}
+
+let sharedGraphemeSegmenter: GraphemeSegmenterLike | null = null
+
+export function getSharedGraphemeSegmenter(): GraphemeSegmenterLike {
+  if (sharedGraphemeSegmenter === null) {
+    if (typeof Intl !== 'undefined' && typeof (Intl as any).Segmenter === 'function') {
+      sharedGraphemeSegmenter = new (Intl as any).Segmenter(undefined, { granularity: 'grapheme' })
+    } else {
+      // Fallback: split on code points via spread operator.
+      // This handles most cases correctly (including astral plane),
+      // but may not perfectly handle complex grapheme clusters (ZWJ emoji).
+      sharedGraphemeSegmenter = {
+        segment(text: string): Iterable<{ segment: string; index: number }> {
+          const chars = [...text]
+          let idx = 0
+          return chars.map(ch => {
+            const entry = { segment: ch, index: idx }
+            idx += ch.length
+            return entry
+          })
+        },
+      }
+    }
+  }
+  return sharedGraphemeSegmenter
+}
+
+export function clearGraphemeSegmenter(): void {
+  sharedGraphemeSegmenter = null
+}
+
+// --- Internal types ---
+
+// The core parallel-array structure that the line-breaking engine operates on.
+// Identical to Pretext's internal representation.
+export type PreparedCore = {
+  widths: number[]
+  lineEndFitAdvances: number[]
+  lineEndPaintAdvances: number[]
+  kinds: SegmentBreakKind[]
+  simpleLineWalkFastPath: boolean
+  segLevels: Int8Array | null
+  breakableWidths: (number[] | null)[]
+  breakablePrefixWidths: (number[] | null)[]
+  discretionaryHyphenWidth: number
+  tabStopAdvance: number
+  chunks: PreparedLineChunk[]
+  style: TextStyle | null
+}
+
+export type InternalPreparedText = PreparedText & PreparedCore
+
+export type InternalPreparedTextWithSegments = InternalPreparedText & {
+  segments: string[]
+}
+
+export type PreparedLineChunk = {
+  startSegmentIndex: number
+  endSegmentIndex: number
+  consumedEndSegmentIndex: number
+}
+
+export type PrepareOptions = {
+  whiteSpace?: WhiteSpaceMode
+  wordBreak?: WordBreakMode
+}
+
+// --- Internal helpers ---
+
+type MeasuredTextUnit = {
+  text: string
+  start: number
+}
+
+function createEmptyPrepared(
+  includeSegments: boolean,
+  style: TextStyle | null,
+): InternalPreparedText | InternalPreparedTextWithSegments {
+  const base: PreparedCore = {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: true,
+    segLevels: null,
+    breakableWidths: [],
+    breakablePrefixWidths: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: [],
+    style,
+  }
+  if (includeSegments) {
+    return { ...base, segments: [] } as unknown as InternalPreparedTextWithSegments
+  }
+  return base as unknown as InternalPreparedText
+}
+
+function buildBaseCjkUnits(
+  segText: string,
+  engineProfile: ReturnType<typeof getEngineProfile>,
+): MeasuredTextUnit[] {
+  const units: MeasuredTextUnit[] = []
+  let unitText = ''
+  let unitStart = 0
+
+  function pushUnit(): void {
+    if (unitText.length === 0) return
+    units.push({ text: unitText, start: unitStart })
+    unitText = ''
+  }
+
+  for (const gs of getSharedGraphemeSegmenter().segment(segText)) {
+    const grapheme = gs.segment
+
+    if (unitText.length === 0) {
+      unitText = grapheme
+      unitStart = gs.index
+      continue
+    }
+
+    if (
+      kinsokuEnd.has(unitText) ||
+      kinsokuStart.has(grapheme) ||
+      leftStickyPunctuation.has(grapheme) ||
+      (engineProfile.carryCJKAfterClosingQuote &&
+        isCJK(grapheme) &&
+        endsWithClosingQuote(unitText))
+    ) {
+      unitText += grapheme
+      continue
+    }
+
+    if (!isCJK(unitText) && !isCJK(grapheme)) {
+      unitText += grapheme
+      continue
+    }
+
+    pushUnit()
+    unitText = grapheme
+    unitStart = gs.index
+  }
+
+  pushUnit()
+  return units
+}
+
+function mergeKeepAllTextUnits(units: MeasuredTextUnit[]): MeasuredTextUnit[] {
+  if (units.length <= 1) return units
+
+  const merged: MeasuredTextUnit[] = [{ ...units[0]! }]
+  for (let i = 1; i < units.length; i++) {
+    const next = units[i]!
+    const previous = merged[merged.length - 1]!
+
+    if (
+      canContinueKeepAllTextRun(previous.text) &&
+      isCJK(previous.text)
+    ) {
+      previous.text += next.text
+      continue
+    }
+
+    merged.push({ ...next })
+  }
+
+  return merged
+}
+
+// Look up width of a sub-segment from the pre-measured width map.
+function lookupWidth(
+  text: string,
+  widthMap: Map<string, number>,
+  parentText: string,
+  parentWidth: number,
+): number {
+  const cached = widthMap.get(text)
+  if (cached !== undefined) return cached
+
+  if (parentText.length > 0 && parentWidth > 0) {
+    return (text.length / parentText.length) * parentWidth
+  }
+  return 0
+}
+
+// Get grapheme widths for a text segment by splitting it and looking up
+// individual grapheme widths from the width map, falling back to equal
+// distribution from the total width.
+function getGraphemeWidthsFromMap(
+  text: string,
+  totalWidth: number,
+  widthMap: Map<string, number>,
+): number[] {
+  const graphemeSegmenter = getSharedGraphemeSegmenter()
+  const graphemes: string[] = []
+  for (const gs of graphemeSegmenter.segment(text)) {
+    graphemes.push(gs.segment)
+  }
+  if (graphemes.length <= 1) return [totalWidth]
+
+  const widths: number[] = []
+  let knownTotal = 0
+  let unknownCount = 0
+  for (const g of graphemes) {
+    const w = widthMap.get(g)
+    if (w !== undefined) {
+      widths.push(w)
+      knownTotal += w
+    } else {
+      widths.push(-1)
+      unknownCount++
+    }
+  }
+
+  if (unknownCount > 0) {
+    const remaining = Math.max(0, totalWidth - knownTotal)
+    const perUnknown = remaining / unknownCount
+    for (let i = 0; i < widths.length; i++) {
+      if (widths[i]! < 0) widths[i] = perUnknown
+    }
+  }
+
+  return widths
+}
+
+// Build cumulative prefix widths from per-grapheme widths.
+function buildPrefixWidths(graphemeWidths: number[]): number[] {
+  const prefixWidths: number[] = new Array(graphemeWidths.length)
+  let sum = 0
+  for (let i = 0; i < graphemeWidths.length; i++) {
+    sum += graphemeWidths[i]!
+    prefixWidths[i] = sum
+  }
+  return prefixWidths
+}
+
+function mapAnalysisChunksToPreparedChunks(
+  chunks: AnalysisChunk[],
+  preparedStartByAnalysisIndex: number[],
+  preparedEndSegmentIndex: number,
+): PreparedLineChunk[] {
+  const preparedChunks: PreparedLineChunk[] = []
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i]!
+    const startSegmentIndex =
+      chunk.startSegmentIndex < preparedStartByAnalysisIndex.length
+        ? preparedStartByAnalysisIndex[chunk.startSegmentIndex]!
+        : preparedEndSegmentIndex
+    const endSegmentIndex =
+      chunk.endSegmentIndex < preparedStartByAnalysisIndex.length
+        ? preparedStartByAnalysisIndex[chunk.endSegmentIndex]!
+        : preparedEndSegmentIndex
+    const consumedEndSegmentIndex =
+      chunk.consumedEndSegmentIndex < preparedStartByAnalysisIndex.length
+        ? preparedStartByAnalysisIndex[chunk.consumedEndSegmentIndex]!
+        : preparedEndSegmentIndex
+
+    preparedChunks.push({
+      startSegmentIndex,
+      endSegmentIndex,
+      consumedEndSegmentIndex,
+    })
+  }
+  return preparedChunks
+}
+
+// --- Build prepared handles from pre-measured data ---
+
+function buildFromAnalysis(
+  analysis: TextAnalysis,
+  widthMap: Map<string, number>,
+  includeSegments: boolean,
+  wordBreak: WordBreakMode,
+  style: TextStyle | null,
+): InternalPreparedText | InternalPreparedTextWithSegments {
+  const engineProfile = getEngineProfile()
+
+  const discretionaryHyphenWidth = widthMap.get('-') ?? (widthMap.get(' ') ?? 0) * 0.6
+  const spaceWidth = widthMap.get(' ') ?? 0
+  const tabStopAdvance = spaceWidth * 8
+
+  if (analysis.len === 0) return createEmptyPrepared(includeSegments, style)
+
+  const widths: number[] = []
+  const lineEndFitAdvances: number[] = []
+  const lineEndPaintAdvances: number[] = []
+  const kinds: SegmentBreakKind[] = []
+  let simpleLineWalkFastPath = analysis.chunks.length <= 1
+  const segStarts = includeSegments ? [] as number[] : null
+  const breakableWidths: (number[] | null)[] = []
+  const breakablePrefixWidths: (number[] | null)[] = []
+  const segments = includeSegments ? [] as string[] : null
+  const preparedStartByAnalysisIndex = Array.from<number>({ length: analysis.len })
+
+  function pushSegment(
+    text: string,
+    width: number,
+    lineEndFitAdvance: number,
+    lineEndPaintAdvance: number,
+    kind: SegmentBreakKind,
+    start: number,
+    breakable: number[] | null,
+    breakablePrefix: number[] | null,
+  ): void {
+    if (kind !== 'text' && kind !== 'space' && kind !== 'zero-width-break') {
+      simpleLineWalkFastPath = false
+    }
+    widths.push(width)
+    lineEndFitAdvances.push(lineEndFitAdvance)
+    lineEndPaintAdvances.push(lineEndPaintAdvance)
+    kinds.push(kind)
+    segStarts?.push(start)
+    breakableWidths.push(breakable)
+    breakablePrefixWidths.push(breakablePrefix)
+    if (segments !== null) segments.push(text)
+  }
+
+  function pushTextSegment(
+    text: string,
+    kind: SegmentBreakKind,
+    start: number,
+    wordLike: boolean,
+    allowOverflowBreaks: boolean,
+    parentText: string,
+    parentWidth: number,
+  ): void {
+    const width = lookupWidth(text, widthMap, parentText, parentWidth)
+    const lineEndFitAdvance =
+      kind === 'space' || kind === 'preserved-space' || kind === 'zero-width-break'
+        ? 0
+        : width
+    const lineEndPaintAdvance =
+      kind === 'space' || kind === 'zero-width-break'
+        ? 0
+        : width
+
+    if (allowOverflowBreaks && wordLike && text.length > 1) {
+      const graphemeWidths = getGraphemeWidthsFromMap(text, width, widthMap)
+      const graphemePrefixWidths =
+        engineProfile.preferPrefixWidthsForBreakableRuns || isNumericRunSegment(text)
+          ? buildPrefixWidths(graphemeWidths)
+          : null
+      pushSegment(
+        text,
+        width,
+        lineEndFitAdvance,
+        lineEndPaintAdvance,
+        kind,
+        start,
+        graphemeWidths,
+        graphemePrefixWidths,
+      )
+      return
+    }
+
+    pushSegment(
+      text,
+      width,
+      lineEndFitAdvance,
+      lineEndPaintAdvance,
+      kind,
+      start,
+      null,
+      null,
+    )
+  }
+
+  for (let mi = 0; mi < analysis.len; mi++) {
+    preparedStartByAnalysisIndex[mi] = widths.length
+    const segText = analysis.texts[mi]!
+    const segWordLike = analysis.isWordLike[mi]!
+    const segKind = analysis.kinds[mi]!
+    const segStart = analysis.starts[mi]!
+
+    if (segKind === 'soft-hyphen') {
+      pushSegment(
+        segText,
+        0,
+        discretionaryHyphenWidth,
+        discretionaryHyphenWidth,
+        segKind,
+        segStart,
+        null,
+        null,
+      )
+      continue
+    }
+
+    if (segKind === 'hard-break') {
+      pushSegment(segText, 0, 0, 0, segKind, segStart, null, null)
+      continue
+    }
+
+    if (segKind === 'tab') {
+      pushSegment(segText, 0, 0, 0, segKind, segStart, null, null)
+      continue
+    }
+
+    const containsCJK = isCJK(segText)
+
+    if (segKind === 'text' && containsCJK) {
+      const parentWidth = widthMap.get(segText) ?? 0
+      const baseUnits = buildBaseCjkUnits(segText, engineProfile)
+      const measuredUnits = wordBreak === 'keep-all'
+        ? mergeKeepAllTextUnits(baseUnits)
+        : baseUnits
+
+      for (let i = 0; i < measuredUnits.length; i++) {
+        const unit = measuredUnits[i]!
+        pushTextSegment(
+          unit.text,
+          'text',
+          segStart + unit.start,
+          segWordLike,
+          wordBreak === 'keep-all' || !isCJK(unit.text),
+          segText,
+          parentWidth,
+        )
+      }
+      continue
+    }
+
+    pushTextSegment(segText, segKind, segStart, segWordLike, true, segText, 0)
+  }
+
+  const chunks = mapAnalysisChunksToPreparedChunks(analysis.chunks, preparedStartByAnalysisIndex, widths.length)
+  const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts)
+
+  const core: PreparedCore = {
+    widths,
+    lineEndFitAdvances,
+    lineEndPaintAdvances,
+    kinds,
+    simpleLineWalkFastPath,
+    segLevels,
+    breakableWidths,
+    breakablePrefixWidths,
+    discretionaryHyphenWidth,
+    tabStopAdvance,
+    chunks,
+    style,
+  }
+
+  if (segments !== null) {
+    return { ...core, segments } as unknown as InternalPreparedTextWithSegments
+  }
+  return core as unknown as InternalPreparedText
+}
+
+// --- Public build functions (called by prepare.ts) ---
+
+export function buildPreparedText(
+  analysis: TextAnalysis,
+  widthMap: Map<string, number>,
+  style: TextStyle,
+  options?: PrepareOptions,
+): PreparedText {
+  const wordBreak = options?.wordBreak ?? 'normal'
+  return buildFromAnalysis(analysis, widthMap, false, wordBreak, style) as PreparedText
+}
+
+export function buildPreparedTextWithSegments(
+  analysis: TextAnalysis,
+  widthMap: Map<string, number>,
+  style: TextStyle,
+  options?: PrepareOptions,
+): PublicPreparedTextWithSegments {
+  const wordBreak = options?.wordBreak ?? 'normal'
+  return buildFromAnalysis(analysis, widthMap, true, wordBreak, style) as unknown as PublicPreparedTextWithSegments
+}