@symbiote-native/engine 0.1.6 → 0.2.0

package/build/native-modules.js

@@ -1,120 +0,0 @@
-// JS -> native: reaching a native (Turbo)Module. The New Architecture installs
-// `global.__turboModuleProxy(name)`: a JSI function that returns the native
-// module registered under `name` (a HostObject whose methods call into native),
-// or null. React Native's own `TurboModuleRegistry.get` is just this call; we are
-// one more client of the same global, exactly as `getSlot` is for the view tree.
-//
-// This is first-party access, for symbiote's own modules (StatusBarManager,
-// KeyboardObserver, ...). Third-party RN packages import `TurboModuleRegistry` from
-// `'react-native'` and read the same global themselves; they do not go through
-// here.
-import { dlog } from './debug.js';
-import { installDeviceEventHub, NativeEventEmitter, } from './native-events.js';
-import { isRecord } from './type-guards.js';
-// The native module value crosses from an untyped HostObject into our types here;
-// the caller vouches for its shape via T (the single trust-boundary narrowing, no
-// per-call `as`). Native modules are always non-null objects.
-function isNativeModule(value) {
-    return value !== null && value !== undefined;
-}
-// The native module `name`, typed as the caller's interface `T`, or null when no
-// module by that name is registered in the binary (or the proxy is absent, e.g.
-// running headless without a fake installed).
-export function getNativeModule(name) {
-    // Non-bridgeless: the function proxy. Call it by name.
-    const turboProxy = globalThis.__turboModuleProxy;
-    if (typeof turboProxy === 'function') {
-        const module = turboProxy(name);
-        if (module !== null && module !== undefined)
-            return module;
-    }
-    // Bridgeless: the HostObject proxy, indexed by name. Guard the access: a
-    // HostObject may throw for an unlinked name, and a throw here would propagate
-    // into a render effect and blank the tree.
-    const bridgelessProxy = globalThis.nativeModuleProxy;
-    if (bridgelessProxy !== undefined) {
-        try {
-            const module = bridgelessProxy[name];
-            if (isNativeModule(module))
-                return module;
-        }
-        catch (error) {
-            dlog(`nativeModuleProxy["${name}"] threw: ${String(error)}`);
-        }
-    }
-    dlog(`native module "${name}" not found ` +
-        `(turbo=${typeof turboProxy}, bridgeless=${typeof globalThis.nativeModuleProxy})`);
-    return null;
-}
-// Same, but throws when the module is missing, for modules a feature hard-depends
-// on (StatusBar without StatusBarManager cannot function, so failing loud beats a
-// silent no-op).
-export function getEnforcingNativeModule(name) {
-    const module = getNativeModule(name);
-    if (module === null) {
-        throw new Error(`Native module "${name}" is not registered in the binary. ` +
-            'Verify it is linked (New Architecture / bridgeless host with __turboModuleProxy installed).');
-    }
-    return module;
-}
-// ---- device-event module factory ------------------------------------------
-//
-// AccessibilityInfo (iOS + Android), AppState, Appearance, BackHandler, Keyboard,
-// and Dimensions each hand-rolled the identical plumbing: lazily resolve a native
-// module, lazily build a NativeEventEmitter bound to it, install the device-event
-// hub on first subscribe. `createLinking` (linking/shared.ts) proved this factors
-// out safely for Linking's iOS/Android split; this is the general form for every
-// other lazy-module + emitter pair in the runtime-module layer.
-//
-// Each caller's DEGRADE POLICY stays its own, via config - the factory owns only
-// the plumbing:
-//   - `bindModuleToEmitter` (default true): whether the resolved module is wired
-//     into the emitter so its addListener/removeListeners observe-counters get
-//     pinged. Dimensions' DeviceInfo module has no observe-counters, so it opts out
-//     (matching its original `new NativeEventEmitter(undefined)`).
-//   - `onEmitterCreated`: runs exactly once, right after the emitter is built -
-//     the hook for a caller's own permanent self-subscription (AppState/Appearance/
-//     BackHandler/Keyboard each keep a cache fresh or dispatch a chain this way) or
-//     one-time hydration from the module's constants (AppState's initial state,
-//     Dimensions' initial metrics - the latter also relies on this hook running
-//     `addListener` BEFORE the constants read, preserving the original
-//     subscribe-before-resolve ordering that guards against missing an update).
-// A structural check, not a cast: narrows an arbitrary resolved module down to
-// IEventEmitterModule only when it actually carries both observe-counter methods.
-// Needed because `TModule` is unconstrained (Dimensions' INativeDeviceInfo doesn't
-// extend IEventEmitterModule at all) - NativeEventEmitter itself re-checks the same
-// shape internally, so this exists to satisfy the type system, not to change
-// behavior.
-function hasEventEmitterShape(value) {
-    return (isRecord(value) &&
-        typeof value.addListener === 'function' &&
-        typeof value.removeListeners === 'function');
-}
-// Build one module's lazy-resolve + lazy-emitter pair. Each call owns its own
-// cache, so two callers (or two platform builds loaded together in one smoke) stay
-// independent - the same guarantee `createLinking` documents.
-export function createDeviceEventModule(config) {
-    let module;
-    let emitter;
-    function getModule() {
-        if (module === undefined) {
-            module = getNativeModule(config.moduleName);
-            dlog(`${config.moduleLogPrefix} ${module ? 'resolved' : 'NOT resolved (null)'}`);
-        }
-        return module;
-    }
-    function getEmitter() {
-        if (emitter === undefined) {
-            // WHY lazy: install on first subscribe so the hub exists before native
-            // emits, without a hard bootstrap-order dependency. Idempotent.
-            installDeviceEventHub();
-            const resolved = getModule();
-            const bindModule = config.bindModuleToEmitter ?? true;
-            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved) ? resolved : undefined;
-            emitter = new NativeEventEmitter(boundModule);
-            config.onEmitterCreated?.(emitter, resolved);
-        }
-        return emitter;
-    }
-    return { getModule, getEmitter };
-}

package/build/style-registry/scope/index.d.ts

@@ -1,3 +0,0 @@
-export type IClassToggleMap = Record<string, boolean | undefined>;
-export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
-export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;

package/build/style-registry/scope/index.js

@@ -1,41 +0,0 @@
-// Vue `<style scoped>` class-name rewriter. Distinct responsibility from the sibling
-// ./index.ts (the CSS class -> style registry): this module does pure NAME rewriting,
-// no registry lookup, no CSS parsing. It runs at the compiled call site of a Vue SFC's
-// scoped-style template - `adapters/vue/metro-vue-transformer.cjs` emits calls to
-// scopeClassName (imported there as `__scopeClass`) - BEFORE Vue's own normalizeClass()
-// collapses string/object/array `class` values to a final string, so it must pre-process
-// all three shapes normalizeClass understands. resolveClassName in ./index.ts still does
-// the actual style lookup, unchanged, against the rewritten (possibly suffixed) name.
-import { kebabToCamel } from '../index.js';
-// Suffixes every class token that this file's scoped block locally defines with
-// `__${scopeId}`, leaving unrecognized tokens (globals, external classes) untouched.
-export function scopeClassName(value, localNames, scopeId) {
-    if (value === undefined || value === null)
-        return value;
-    if (Array.isArray(value)) {
-        return value.map(item => scopeClassEntry(item, localNames, scopeId));
-    }
-    return scopeClassEntry(value, localNames, scopeId);
-}
-// A token arrives as either the camelCase registry key (`sectionLabel`) or its kebab-case
-// authoring form (`section-label`) - normalize to camelCase FIRST, then decide scoping, so
-// `localNames` (always camelCase, built from the css-parser's registered keys) recognizes a
-// kebab-written token. The emitted (possibly suffixed) name is always the camelCase form.
-function scopeToken(token, localNames, scopeId) {
-    const camelToken = kebabToCamel(token);
-    return localNames.has(camelToken) ? `${camelToken}__${scopeId}` : camelToken;
-}
-function scopeClassEntry(value, localNames, scopeId) {
-    if (typeof value === 'object') {
-        const scoped = {};
-        for (const [name, enabled] of Object.entries(value)) {
-            scoped[scopeToken(name, localNames, scopeId)] = enabled;
-        }
-        return scoped;
-    }
-    return value
-        .split(/\s+/)
-        .filter(Boolean)
-        .map(token => scopeToken(token, localNames, scopeId))
-        .join(' ');
-}

package/build/touch-history/index.d.ts

@@ -1,23 +0,0 @@
-interface ITouchRecord {
-    touchActive: boolean;
-    startPageX: number;
-    startPageY: number;
-    startTimeStamp: number;
-    currentPageX: number;
-    currentPageY: number;
-    currentTimeStamp: number;
-    previousPageX: number;
-    previousPageY: number;
-    previousTimeStamp: number;
-}
-interface ITouchHistory {
-    touchBank: ITouchRecord[];
-    numberActiveTouches: number;
-    indexOfSingleActiveTouch: number;
-    mostRecentTimeStamp: number;
-}
-export declare const touchHistory: ITouchHistory;
-export declare function recordTouchTrack(kind: 'start' | 'move' | 'end', nativeEvent: Record<string, unknown>): void;
-export declare function resetTouchHistory(): void;
-export declare function attachTouchHistory(nativeEvent: Record<string, unknown>): void;
-export {};

package/build/touch-history/index.js

@@ -1,150 +0,0 @@
-// Per-touch position/time tracking, ported from RN's
-// react-native-renderer/.../legacy-events/ResponderTouchHistoryStore.js. PanResponder's
-// multitouch dx/vx math needs each touch's own previous->current delta (RN counts only
-// touches that moved since `_accountsForMovesUpTo`), which a grant-relative centroid of
-// ALL live touches cannot reconstruct. We maintain the bank as touches flow and ATTACH
-// `touchHistory` onto the nativeEvent reaching responder handlers, exactly how
-// ResponderEventPlugin.js sets `*.touchHistory`.
-//
-// events/index.ts consumes only this file's public surface (recordTouchTrack,
-// attachTouchHistory, resetTouchHistory, touchHistory); everything else here is a
-// private implementation detail of the bank.
-import { isRecord } from '../type-guards.js';
-// RN's bank is indexed by touch identifier and warns above 20; we never warn (headless
-// events may carry larger or absent ids), we just skip anything out of a sane range.
-const MAX_TOUCH_BANK = 20;
-const touchBank = [];
-export const touchHistory = {
-    touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0,
-};
-function toFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-// Pull a recordable touch out of an untyped entry. RN's getTouchIdentifier throws on
-// a null id; we skip instead, so events without touch geometry leave the bank untouched.
-function normalizeTouch(raw) {
-    if (!isRecord(raw))
-        return undefined;
-    const identifier = toFiniteNumber(raw.identifier);
-    const pageX = toFiniteNumber(raw.pageX);
-    const pageY = toFiniteNumber(raw.pageY);
-    if (identifier === undefined || pageX === undefined || pageY === undefined)
-        return undefined;
-    if (identifier < 0 || identifier > MAX_TOUCH_BANK)
-        return undefined;
-    return { identifier, pageX, pageY, timestamp: toFiniteNumber(raw.timestamp) ?? 0 };
-}
-// The changed touches for this frame (start/move/end), defensively read.
-function changedTouchesOf(nativeEvent) {
-    const raw = nativeEvent.changedTouches;
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const entry of raw) {
-        const touch = normalizeTouch(entry);
-        if (touch !== undefined)
-            out.push(touch);
-    }
-    return out;
-}
-// Count of all touches still down (RN reads nativeEvent.touches.length directly).
-function activeTouchCount(nativeEvent) {
-    const raw = nativeEvent.touches;
-    return Array.isArray(raw) ? raw.length : 0;
-}
-function recordTouchStart(touch) {
-    const record = touchBank[touch.identifier];
-    if (record) {
-        record.touchActive = true;
-        record.startPageX = touch.pageX;
-        record.startPageY = touch.pageY;
-        record.startTimeStamp = touch.timestamp;
-        record.currentPageX = touch.pageX;
-        record.currentPageY = touch.pageY;
-        record.currentTimeStamp = touch.timestamp;
-        record.previousPageX = touch.pageX;
-        record.previousPageY = touch.pageY;
-        record.previousTimeStamp = touch.timestamp;
-    }
-    else {
-        touchBank[touch.identifier] = {
-            touchActive: true,
-            startPageX: touch.pageX,
-            startPageY: touch.pageY,
-            startTimeStamp: touch.timestamp,
-            currentPageX: touch.pageX,
-            currentPageY: touch.pageY,
-            currentTimeStamp: touch.timestamp,
-            previousPageX: touch.pageX,
-            previousPageY: touch.pageY,
-            previousTimeStamp: touch.timestamp,
-        };
-    }
-    touchHistory.mostRecentTimeStamp = touch.timestamp;
-}
-// Move and end share the previous<-current shift; only `touchActive` differs.
-function shiftTouchRecord(touch, active) {
-    const record = touchBank[touch.identifier];
-    if (!record)
-        return;
-    record.touchActive = active;
-    record.previousPageX = record.currentPageX;
-    record.previousPageY = record.currentPageY;
-    record.previousTimeStamp = record.currentTimeStamp;
-    record.currentPageX = touch.pageX;
-    record.currentPageY = touch.pageY;
-    record.currentTimeStamp = touch.timestamp;
-    touchHistory.mostRecentTimeStamp = touch.timestamp;
-}
-function arrayFirst(value) {
-    return Array.isArray(value) ? value[0] : undefined;
-}
-// Maintain the bank as a touch frame flows. Mirrors RN's recordTouchTrack: moveish
-// shifts records, startish records + recomputes numberActiveTouches, endish marks the
-// record inactive + rescans for the single remaining touch. `kind` is the touch phase.
-export function recordTouchTrack(kind, nativeEvent) {
-    if (kind === 'move') {
-        for (const touch of changedTouchesOf(nativeEvent))
-            shiftTouchRecord(touch, true);
-        return;
-    }
-    if (kind === 'start') {
-        for (const touch of changedTouchesOf(nativeEvent))
-            recordTouchStart(touch);
-        touchHistory.numberActiveTouches = activeTouchCount(nativeEvent);
-        if (touchHistory.numberActiveTouches === 1) {
-            const first = normalizeTouch(arrayFirst(nativeEvent.touches));
-            touchHistory.indexOfSingleActiveTouch = first?.identifier ?? -1;
-        }
-        return;
-    }
-    for (const touch of changedTouchesOf(nativeEvent))
-        shiftTouchRecord(touch, false);
-    touchHistory.numberActiveTouches = activeTouchCount(nativeEvent);
-    if (touchHistory.numberActiveTouches === 1) {
-        for (let i = 0; i < touchBank.length; i++) {
-            const record = touchBank[i];
-            if (record !== undefined && record.touchActive) {
-                touchHistory.indexOfSingleActiveTouch = i;
-                break;
-            }
-        }
-    }
-}
-// Drop all touch state. Called on a fully-released / cancelled gesture so a stale bank
-// never leaks geometry into the next gesture's first frame.
-export function resetTouchHistory() {
-    touchBank.length = 0;
-    touchHistory.numberActiveTouches = 0;
-    touchHistory.indexOfSingleActiveTouch = -1;
-    touchHistory.mostRecentTimeStamp = 0;
-}
-// Attach the live touch history onto the event the responder handlers receive, matching
-// ResponderEventPlugin.js (`grantEvent.touchHistory = ...`, etc.). PanResponder reads
-// it for the per-touch dx/vx math; handlers that ignore it are unaffected.
-export function attachTouchHistory(nativeEvent) {
-    nativeEvent.touchHistory = touchHistory;
-}

package/build/type-guards/index.d.ts

@@ -1,4 +0,0 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function isBoolean(value: unknown): value is boolean;
-export declare function isNumber(value: unknown): value is number;
-export declare function isString(value: unknown): value is string;

package/build/type-guards/index.js

@@ -1,15 +0,0 @@
-// Runtime guards to narrow `unknown` at trust boundaries (native payloads, ViewConfig
-// attributes, style values) without an `as` cast. `isRecord` excludes arrays - most
-// call sites mean "a native payload keyed by string," never a list.
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function isBoolean(value) {
-    return typeof value === 'boolean';
-}
-export function isNumber(value) {
-    return typeof value === 'number';
-}
-export function isString(value) {
-    return typeof value === 'string';
-}