expo-pretext 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## 0.2.0 — 2026-04-08
+
+### Added
+
+- **obstacle-layout module** — `carveTextLineSlots`, `circleIntervalForBand`, `rectIntervalForBand`, `layoutColumn` for text reflow around obstacles
+- **TextKit primary measurement** — `useTextHeight`, `useFlashListHeights`, `measureHeights` now use NSLayoutManager for pixel-perfect accuracy matching RN Text
+- **8 demo screens** — Editorial Engine, Tight Bubbles, Accordion, Masonry, i18n, Markdown Chat, Justification Comparison, ASCII Art
+- **`measureTextHeight` native function** — NSLayoutManager-based height measurement on iOS
+
+### Fixed
+
+- CJK/Georgian/Mixed text accuracy — TextKit measurement matches RN Text exactly
+- Intl.Segmenter fallback for Hermes — grapheme splitting works without polyfill
+- System font detection — no false warnings for built-in iOS fonts
+- iOS native module CFLocale type mismatch
+
+## 0.1.0 — 2026-04-05
+
+### Added
+
+- Initial release of expo-pretext
+- Core API: `prepare()`, `layout()`, `prepareWithSegments()`, `layoutWithLines()`, `layoutNextLine()`, `walkLineRanges()`, `measureNaturalWidth()`
+- React hooks: `useTextHeight()`, `usePreparedText()`, `useFlashListHeights()`
+- Rich inline: `prepareInlineFlow()`, `walkInlineFlowLines()`, `measureInlineFlow()`
+- Batch: `measureHeights()`
+- iOS native module (Swift) — CFStringTokenizer + CTLine measurement
+- Android native module (Kotlin) — BreakIterator + TextPaint measurement
+- Auto-batching, JS-side caching, incremental streaming extend
+- Ported from Pretext v0.0.4 (chenglou/pretext)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juba Kitiashvili
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# expo-pretext
+
+DOM-free multiline text height prediction for React Native. Port of [Pretext](https://github.com/chenglou/pretext).
+
+Predict text heights **before rendering** — no `onLayout`, no layout jumps, no guesswork. Works with FlashList, streaming AI chat, and any layout that needs text dimensions upfront.
+
+## Demos
+
+<table>
+  <tr>
+    <td align="center"><strong>AI Chat</strong></td>
+    <td align="center"><strong>Accuracy</strong></td>
+    <td align="center"><strong>Editorial Engine</strong></td>
+  </tr>
+  <tr>
+    <td align="center">
+      <video src="https://github.com/JubaKitiashvili/expo-pretext/raw/main/assets/demos/ai-chat.mp4" width="240" />
+    </td>
+    <td align="center">
+      <video src="https://github.com/JubaKitiashvili/expo-pretext/raw/main/assets/demos/accuracy.mp4" width="240" />
+    </td>
+    <td align="center">
+      <video src="https://github.com/JubaKitiashvili/expo-pretext/raw/main/assets/demos/editorial-engine.mp4" width="240" />
+    </td>
+  </tr>
+  <tr>
+    <td align="center"><sub>FlashList + streaming + markdown</sub></td>
+    <td align="center"><sub>Predicted vs actual height</sub></td>
+    <td align="center"><sub>Text reflow around obstacles</sub></td>
+  </tr>
+</table>
+
+## Installation
+
+```sh
+npx expo install expo-pretext
+```
+
+> Requires Expo SDK 52+ with a development build. Expo Go falls back to JS estimates.
+
+## Quick Start
+
+```tsx
+import { useTextHeight } from 'expo-pretext'
+
+function ChatBubble({ text }) {
+  const height = useTextHeight(text, {
+    fontFamily: 'Inter',
+    fontSize: 16,
+    lineHeight: 24,
+  }, maxWidth)
+
+  return <View style={{ height }}><Text>{text}</Text></View>
+}
+```
+
+## FlashList Integration
+
+```tsx
+import { useFlashListHeights } from 'expo-pretext'
+
+function ChatScreen() {
+  const { estimatedItemSize, overrideItemLayout } = useFlashListHeights(
+    messages,
+    msg => msg.text,
+    { fontFamily: 'Inter', fontSize: 16, lineHeight: 24 },
+    containerWidth
+  )
+
+  return (
+    <FlashList
+      data={messages}
+      estimatedItemSize={estimatedItemSize}
+      overrideItemLayout={overrideItemLayout}
+      renderItem={renderMessage}
+    />
+  )
+}
+```
+
+## Streaming AI Chat
+
+```tsx
+function StreamingMessage({ text }) {
+  // Automatically detects append pattern, uses incremental measurement
+  // Native cache means most segments are instant cache hits
+  const height = useTextHeight(text, style, maxWidth)
+  return <View style={{ minHeight: height }}><Text>{text}</Text></View>
+}
+```
+
+## Batch Measurement
+
+```tsx
+import { measureHeights } from 'expo-pretext'
+
+// One native call for all texts
+const heights = measureHeights(
+  ['Hello world', 'Longer paragraph...', '短い文'],
+  { fontFamily: 'Inter', fontSize: 16, lineHeight: 24 },
+  320
+)
+```
+
+## API Reference
+
+### Simple API
+
+| Function | Description |
+|---|---|
+| `useTextHeight(text, style, maxWidth)` | Returns height as number. Auto-optimizes for streaming. |
+| `useFlashListHeights(data, getText, style, maxWidth)` | Returns `{ estimatedItemSize, overrideItemLayout }` for FlashList. |
+| `usePreparedText(text, style)` | Returns PreparedText handle for manual layout. |
+| `measureHeights(texts, style, maxWidth)` | Batch: texts in, heights out. |
+
+### Power API (Pretext-compatible)
+
+| Function | Description |
+|---|---|
+| `prepare(text, style, options?)` | One-time measurement. Returns opaque PreparedText. |
+| `layout(prepared, maxWidth)` | Pure arithmetic height calculation. ~0.0002ms. |
+| `prepareWithSegments(text, style, options?)` | Rich variant with segment data. |
+| `layoutWithLines(prepared, maxWidth)` | Returns `{ height, lineCount, lines }`. |
+| `layoutNextLine(prepared, start, maxWidth)` | Iterator for variable-width layouts. |
+| `walkLineRanges(prepared, maxWidth, onLine)` | Line walker without string materialization. |
+| `measureNaturalWidth(prepared)` | Intrinsic width (widest forced line). |
+
+### Rich Inline API
+
+| Function | Description |
+|---|---|
+| `prepareInlineFlow(items)` | Mixed fonts, @mention pills, chips. Returns opaque PreparedInlineFlow. |
+| `walkInlineFlowLines(prepared, maxWidth, onLine)` | Line walker for inline fragments. Calls `onLine(fragments[], y, lineHeight)` per line. |
+| `measureInlineFlow(prepared, maxWidth)` | Total height for inline fragment stream. |
+
+### Streaming API
+
+For AI chat and real-time text append scenarios without hooks:
+
+| Function | Description |
+|---|---|
+| `prepareStreaming(key, text, style, options?)` | Optimized prepare for growing text. Warms cache with new suffix, reuses previous segments. `key` is any object used to track state. |
+| `clearStreamingState(key)` | Clean up streaming state when conversation resets. |
+
+### Obstacle Layout API
+
+For flowing text around shapes (circles, rectangles) — editorial/magazine layouts:
+
+| Function | Description |
+|---|---|
+| `layoutColumn(prepared, options)` | Flow text in a column with obstacles. Returns `{ lines, height }`. |
+| `carveTextLineSlots(lineY, lineHeight, maxWidth, obstacles)` | Compute available text slots for a line, avoiding obstacles. |
+| `circleIntervalForBand(circle, bandTop, bandBottom)` | Horizontal interval a circle occupies at a given vertical band. |
+| `rectIntervalForBand(rect, bandTop, bandBottom)` | Horizontal interval a rectangle occupies at a given vertical band. |
+
+### Types
+
+```ts
+type TextStyle = {
+  fontFamily: string
+  fontSize: number
+  lineHeight?: number
+  fontWeight?: '400' | '500' | '600' | '700' | 'bold' | 'normal'
+  fontStyle?: 'normal' | 'italic'
+}
+
+type PrepareOptions = {
+  whiteSpace?: 'normal' | 'pre-wrap'
+  locale?: string
+  accuracy?: 'fast' | 'exact'
+}
+
+type InlineFlowItem = {
+  text: string
+  style: TextStyle
+  atomic?: boolean      // no breaking inside (pills, chips)
+  extraWidth?: number   // padding/border chrome
+}
+```
+
+### Obstacle Layout Types
+
+```ts
+type CircleObstacle = { type: 'circle'; cx: number; cy: number; r: number }
+type RectObstacle = { type: 'rect'; x: number; y: number; width: number; height: number }
+type LayoutRegion = { x: number; width: number }
+type PositionedLine = { text: string; x: number; y: number; width: number }
+```
+
+### Utilities
+
+```ts
+clearCache()              // Clear all measurement caches
+setLocale(locale?: string) // Set locale for text segmentation
+```
+
+## How It Works
+
+```
+prepare(text, style)
+  → Native: segment text + measure widths (one call)
+  → JS: analyze segments, build PreparedText
+  → Cache everything for next time
+
+layout(prepared, maxWidth)
+  → Pure JS arithmetic on cached widths
+  → ~0.0002ms per text
+  → No native calls, no DOM, no layout reflow
+```
+
+### Performance
+
+- **prepare()**: ~15ms for 500 texts (batch)
+- **layout()**: ~0.0002ms per text (pure arithmetic)
+- **Streaming**: ~2ms per token (mostly cache hits)
+- **Native caching**: LRU 5000 segments/font, frequency-based eviction
+- **JS caching**: skip native calls entirely when all segments are cached
+
+## Accuracy
+
+expo-pretext uses native platform text measurement (iOS `NSString.size`, Android `TextPaint.measureText`) — the same engines that render your text. Two accuracy modes:
+
+- **`fast`** (default): Sum individual segment widths. Sub-pixel kerning differences absorbed by tolerance.
+- **`exact`**: Re-measure merged segments. Pixel-perfect at cost of one extra native call.
+
+## i18n Support
+
+Full Unicode support via native OS segmenters:
+- CJK (Chinese, Japanese, Korean) — per-character breaking + kinsoku rules
+- Arabic, Hebrew — RTL with bidi metadata
+- Thai, Lao, Khmer, Myanmar — dictionary-based word boundaries
+- Georgian, Devanagari, and all other scripts
+- Emoji — compound graphemes, flags, ZWJ sequences
+- Mixed scripts in a single string
+
+## Inspiration & Credits
+
+expo-pretext is a React Native / Expo port of [Pretext](https://github.com/chenglou/pretext) by Cheng Lou. The original Pretext is a web-based text measurement library — expo-pretext brings the same core idea (predict text dimensions before rendering) to the native mobile world, using iOS TextKit and Android TextPaint for measurement instead of DOM APIs.
+
+Key differences from the original:
+- **Native measurement** via Expo modules (iOS `NSString.size`, Android `TextPaint.measureText`)
+- **React Native hooks** (`useTextHeight`, `useFlashListHeights`) for declarative usage
+- **Streaming optimizations** for AI chat use cases
+- **Rich inline flow** for mixed-font content (pills, badges, @mentions)
+
+Pretext itself builds on Sebastian Markbage's [text-layout](https://github.com/nicolo-ribaudo/text-layout) research.
+
+## License
+
+MIT

package/android/src/main/java/expo/modules/pretext/ExpoPretextModule.kt

@@ -0,0 +1,354 @@
+package expo.modules.pretext
+
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.TextPaint
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.text.BreakIterator
+import java.util.Locale
+
+/**
+ * Data class for a cached measurement entry.
+ * Tracks the measured width and a hit counter for LRU eviction.
+ */
+private data class CacheEntry(
+    val width: Double,
+    var hits: Int = 0
+)
+
+class ExpoPretextModule : Module() {
+
+    // ── Caches ──────────────────────────────────────────────────────────────
+
+    /** Font/TextPaint cache keyed by "family_size_weight_style" */
+    private val fontCache = mutableMapOf<String, TextPaint>()
+
+    /**
+     * Measurement cache: outer key = font key, inner key = segment text.
+     * Each entry records the measured width and a hit counter.
+     */
+    private val measureCache = mutableMapOf<String, MutableMap<String, CacheEntry>>()
+
+    /** Maximum number of segment entries per font in the measurement cache. */
+    private var maxCacheSize: Int = 5000
+
+    // ── Whitespace regexes (compiled once) ──────────────────────────────────
+
+    private val collapseWhitespaceRegex = Regex("\\s+")
+    private val lineEndingRegex = Regex("\\r\\n|\\r")
+
+    // ── Module definition ───────────────────────────────────────────────────
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoPretext")
+
+        // ── segmentAndMeasure ───────────────────────────────────────────
+        Function("segmentAndMeasure") { text: String, font: Map<String, Any>, options: Map<String, Any>? ->
+            segmentAndMeasureInternal(text, font, options)
+        }
+
+        // ── batchSegmentAndMeasure ──────────────────────────────────────
+        Function("batchSegmentAndMeasure") { texts: List<String>, font: Map<String, Any>, options: Map<String, Any>? ->
+            texts.map { text -> segmentAndMeasureInternal(text, font, options) }
+        }
+
+        // ── measureGraphemeWidths ───────────────────────────────────────
+        Function("measureGraphemeWidths") { segment: String, font: Map<String, Any> ->
+            measureGraphemeWidthsInternal(segment, font)
+        }
+
+        // ── remeasureMerged ─────────────────────────────────────────────
+        Function("remeasureMerged") { segments: List<String>, font: Map<String, Any> ->
+            remeasureMergedInternal(segments, font)
+        }
+
+        // ── segmentAndMeasureAsync ──────────────────────────────────────
+        AsyncFunction("segmentAndMeasureAsync") { text: String, font: Map<String, Any>, options: Map<String, Any>? ->
+            segmentAndMeasureInternal(text, font, options)
+        }
+
+        // ── clearNativeCache ────────────────────────────────────────────
+        Function("clearNativeCache") {
+            fontCache.clear()
+            measureCache.clear()
+        }
+
+        // ── setNativeCacheSize ──────────────────────────────────────────
+        Function("setNativeCacheSize") { size: Int ->
+            maxCacheSize = size
+        }
+    }
+
+    // ── Core implementation ─────────────────────────────────────────────────
+
+    /**
+     * Segment text using BreakIterator.getWordInstance, measure each segment,
+     * and return segments / isWordLike / widths arrays.
+     */
+    private fun segmentAndMeasureInternal(
+        text: String,
+        fontMap: Map<String, Any>,
+        optionsMap: Map<String, Any>?
+    ): Map<String, Any> {
+        val whiteSpace = (optionsMap?.get("whiteSpace") as? String) ?: "normal"
+        val localeStr = optionsMap?.get("locale") as? String
+        val locale = if (localeStr != null) Locale.forLanguageTag(localeStr) else Locale.getDefault()
+
+        // Normalize whitespace
+        val normalized = normalizeWhitespace(text, whiteSpace)
+
+        // Resolve paint
+        val paint = getOrCreatePaint(fontMap)
+        val fontKey = fontKeyFrom(fontMap)
+
+        // Word-level segmentation
+        val rawSegments = wordSegment(normalized, locale)
+
+        // Build output arrays
+        val segments = mutableListOf<String>()
+        val isWordLike = mutableListOf<Boolean>()
+        val widths = mutableListOf<Double>()
+
+        for (seg in rawSegments) {
+            val wordLike = isWordLikeSegment(seg)
+
+            if (!wordLike && whiteSpace == "pre-wrap") {
+                // In pre-wrap mode, split non-word segments into individual characters
+                for (ch in seg) {
+                    val s = ch.toString()
+                    segments.add(s)
+                    isWordLike.add(false)
+                    widths.add(cachedMeasure(s, paint, fontKey))
+                }
+            } else {
+                segments.add(seg)
+                isWordLike.add(wordLike)
+                widths.add(cachedMeasure(seg, paint, fontKey))
+            }
+        }
+
+        return mapOf(
+            "segments" to segments,
+            "isWordLike" to isWordLike,
+            "widths" to widths
+        )
+    }
+
+    /**
+     * Measure individual grapheme widths within a segment
+     * using BreakIterator.getCharacterInstance.
+     */
+    private fun measureGraphemeWidthsInternal(
+        segment: String,
+        fontMap: Map<String, Any>
+    ): List<Double> {
+        val paint = getOrCreatePaint(fontMap)
+        val graphemes = graphemeSegment(segment)
+        return graphemes.map { g ->
+            paint.measureText(g).toDouble()
+        }
+    }
+
+    /**
+     * Re-measure a list of pre-split segments with the given font.
+     * Returns a list of widths corresponding 1:1 with the input segments.
+     */
+    private fun remeasureMergedInternal(
+        segments: List<String>,
+        fontMap: Map<String, Any>
+    ): List<Double> {
+        val paint = getOrCreatePaint(fontMap)
+        val fontKey = fontKeyFrom(fontMap)
+        return segments.map { seg ->
+            cachedMeasure(seg, paint, fontKey)
+        }
+    }
+
+    // ── Segmentation helpers ────────────────────────────────────────────────
+
+    /**
+     * Segment text into word-level boundaries using ICU BreakIterator.
+     */
+    private fun wordSegment(text: String, locale: Locale): List<String> {
+        if (text.isEmpty()) return emptyList()
+
+        val bi = BreakIterator.getWordInstance(locale)
+        bi.setText(text)
+
+        val segments = mutableListOf<String>()
+        var start = bi.first()
+        var end = bi.next()
+
+        while (end != BreakIterator.DONE) {
+            segments.add(text.substring(start, end))
+            start = end
+            end = bi.next()
+        }
+
+        return segments
+    }
+
+    /**
+     * Segment text into grapheme clusters using BreakIterator.getCharacterInstance.
+     */
+    private fun graphemeSegment(text: String): List<String> {
+        if (text.isEmpty()) return emptyList()
+
+        val bi = BreakIterator.getCharacterInstance()
+        bi.setText(text)
+
+        val graphemes = mutableListOf<String>()
+        var start = bi.first()
+        var end = bi.next()
+
+        while (end != BreakIterator.DONE) {
+            graphemes.add(text.substring(start, end))
+            start = end
+            end = bi.next()
+        }
+
+        return graphemes
+    }
+
+    /**
+     * Determine if a segment is "word-like" — i.e., contains at least one
+     * letter or digit character.
+     */
+    private fun isWordLikeSegment(segment: String): Boolean {
+        return segment.any { Character.isLetterOrDigit(it) }
+    }
+
+    // ── Whitespace normalization ────────────────────────────────────────────
+
+    /**
+     * In "normal" mode: collapse runs of whitespace to a single space.
+     * In "pre-wrap" mode: normalize line endings (\r\n and \r -> \n) only.
+     */
+    private fun normalizeWhitespace(text: String, mode: String): String {
+        return when (mode) {
+            "pre-wrap" -> lineEndingRegex.replace(text, "\n")
+            else -> collapseWhitespaceRegex.replace(text, " ")
+        }
+    }
+
+    // ── Font / Paint helpers ────────────────────────────────────────────────
+
+    /**
+     * Build a stable cache key from the font descriptor map.
+     */
+    private fun fontKeyFrom(fontMap: Map<String, Any>): String {
+        val family = (fontMap["fontFamily"] as? String) ?: "sans-serif"
+        val size = fontMap["fontSize"]?.let { toDouble(it) } ?: 14.0
+        val weight = (fontMap["fontWeight"] as? String) ?: "400"
+        val style = (fontMap["fontStyle"] as? String) ?: "normal"
+        return "${family}_${size}_${weight}_${style}"
+    }
+
+    /**
+     * Get or create a TextPaint for the given font descriptor.
+     * Cached by fontKey to avoid repeated Typeface resolution and Paint creation.
+     */
+    private fun getOrCreatePaint(fontMap: Map<String, Any>): TextPaint {
+        val key = fontKeyFrom(fontMap)
+        return fontCache.getOrPut(key) {
+            val family = (fontMap["fontFamily"] as? String) ?: "sans-serif"
+            val size = fontMap["fontSize"]?.let { toDouble(it) }?.toFloat() ?: 14f
+            val weight = (fontMap["fontWeight"] as? String) ?: "400"
+            val style = (fontMap["fontStyle"] as? String) ?: "normal"
+
+            val typefaceStyle = resolveTypefaceStyle(weight, style)
+            val typeface = Typeface.create(family, typefaceStyle)
+
+            TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
+                this.typeface = typeface
+                this.textSize = size
+            }
+        }
+    }
+
+    /**
+     * Map fontWeight + fontStyle to a Typeface style int.
+     * Android Typeface supports: NORMAL, BOLD, ITALIC, BOLD_ITALIC.
+     */
+    private fun resolveTypefaceStyle(weight: String, style: String): Int {
+        val isBold = when (weight) {
+            "bold", "700", "800", "900" -> true
+            else -> {
+                val numericWeight = weight.toIntOrNull() ?: 400
+                numericWeight >= 700
+            }
+        }
+        val isItalic = style == "italic"
+
+        return when {
+            isBold && isItalic -> Typeface.BOLD_ITALIC
+            isBold -> Typeface.BOLD
+            isItalic -> Typeface.ITALIC
+            else -> Typeface.NORMAL
+        }
+    }
+
+    // ── Measurement with LRU cache ──────────────────────────────────────────
+
+    /**
+     * Measure a segment with caching. Each font gets its own sub-map.
+     * When a sub-map exceeds maxCacheSize, the entry with the lowest hit
+     * count is evicted.
+     */
+    private fun cachedMeasure(segment: String, paint: TextPaint, fontKey: String): Double {
+        val fontMap = measureCache.getOrPut(fontKey) { mutableMapOf() }
+        val existing = fontMap[segment]
+
+        if (existing != null) {
+            existing.hits++
+            return existing.width
+        }
+
+        // Measure fresh
+        val width = paint.measureText(segment).toDouble()
+        fontMap[segment] = CacheEntry(width = width, hits = 1)
+
+        // LRU eviction: if over capacity, remove the least-hit entry
+        if (fontMap.size > maxCacheSize) {
+            evictLeastUsed(fontMap)
+        }
+
+        return width
+    }
+
+    /**
+     * Evict the entry with the lowest hit count from the given cache map.
+     */
+    private fun evictLeastUsed(cache: MutableMap<String, CacheEntry>) {
+        var minKey: String? = null
+        var minHits = Int.MAX_VALUE
+
+        for ((key, entry) in cache) {
+            if (entry.hits < minHits) {
+                minHits = entry.hits
+                minKey = key
+            }
+        }
+
+        if (minKey != null) {
+            cache.remove(minKey)
+        }
+    }
+
+    // ── Utility ─────────────────────────────────────────────────────────────
+
+    /**
+     * Safely convert Any to Double, handling Int/Long/Float/Double/String.
+     */
+    private fun toDouble(value: Any): Double {
+        return when (value) {
+            is Double -> value
+            is Float -> value.toDouble()
+            is Int -> value.toDouble()
+            is Long -> value.toDouble()
+            is String -> value.toDoubleOrNull() ?: 14.0
+            else -> 14.0
+        }
+    }
+}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["ExpoPretext"]
+  },
+  "android": {
+    "modules": ["expo.modules.pretext.ExpoPretextModule"]
+  }
+}

package/ios/ExpoPretext.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoPretext'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['repository']['url']
+  s.platforms      = { :ios => '15.1' }
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.source_files = '**/*.swift'
+end