@symbiote-native/engine 0.1.0

package/build/pixel-ratio/index.js

@@ -0,0 +1,27 @@
+// PixelRatio: device pixel density helpers, a faithful port of RN's
+// Libraries/Utilities/PixelRatio.js. Every value derives from
+// Dimensions.get('window'): `get()` is the pixel scale, `getFontScale()` the user's
+// text-size factor (falling back to scale when unset), and the two conversion
+// helpers snap layout sizes (dp) onto the physical pixel grid. iOS-only
+// startDetecting() is a no-op, kept for API parity.
+import { Dimensions } from '../dimensions';
+export const PixelRatio = {
+    get() {
+        return Dimensions.get('window').scale;
+    },
+    // RN: fontScale || get(). A 0/absent fontScale falls back to the pixel scale.
+    getFontScale() {
+        return Dimensions.get('window').fontScale || PixelRatio.get();
+    },
+    // dp -> px, guaranteed integer.
+    getPixelSizeForLayoutSize(layoutSize) {
+        return Math.round(layoutSize * PixelRatio.get());
+    },
+    // Snap a dp size to the nearest value that maps to a whole number of pixels.
+    roundToNearestPixel(layoutSize) {
+        const ratio = PixelRatio.get();
+        return Math.round(layoutSize * ratio) / ratio;
+    },
+    // No-op on iOS (web-only in RN). Kept for API parity.
+    startDetecting() { },
+};

package/build/platform/index.android.d.ts

@@ -0,0 +1,22 @@
+import { type IPlatformStatic } from './shared';
+export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic } from './shared';
+export interface IPlatformConstantsAndroid {
+    isTesting: boolean;
+    isDisableAnimations?: boolean;
+    reactNativeVersion: {
+        major: number;
+        minor: number;
+        patch: number;
+        prerelease?: number | string | null;
+    };
+    Version: number;
+    Release: string;
+    Serial: string;
+    Fingerprint: string;
+    Model: string;
+    ServerHost?: string;
+    uiMode: string;
+    Brand: string;
+    Manufacturer: string;
+}
+export declare const Platform: IPlatformStatic<IPlatformConstantsAndroid>;

package/build/platform/index.android.js

@@ -0,0 +1,60 @@
+// The Android Platform: a faithful port of RN's Libraries/Utilities/Platform.android.js.
+// `OS` is the static 'android'; `Version` is the numeric API level and the rest come
+// from the PlatformConstants native module (RN spec NativePlatformConstantsAndroid.js,
+// a different payload from iOS). Metro picks this on an Android host. The module name is
+// the same 'PlatformConstants'; only the shape differs. See .docs/decisions/0022.
+import { createConstantsResolver } from './shared';
+// The filename already selected this host: 'android' is a literal, not a probe.
+const OS_ANDROID = 'android';
+// RN reads isTV off the uiMode constant.
+const UI_MODE_TV = 'tv';
+// Native unresolvable (headless): RN's Version getter would throw; we return 0, the
+// neutral "unknown API level", so a Platform read never crashes a render.
+const UNKNOWN_API_LEVEL = 0;
+function isPlatformConstantsAndroid(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'Version' in value && 'uiMode' in value;
+}
+const resolveConstants = createConstantsResolver(isPlatformConstantsAndroid);
+export const Platform = {
+    OS: OS_ANDROID,
+    get Version() {
+        return resolveConstants()?.Version ?? UNKNOWN_API_LEVEL;
+    },
+    get constants() {
+        return resolveConstants();
+    },
+    // RN Android's Platform has no isPad / isMacCatalyst; they're always false here so app
+    // code can read them uniformly across hosts (RN parity: those are iOS-only concepts).
+    get isPad() {
+        return false;
+    },
+    get isTV() {
+        return resolveConstants()?.uiMode === UI_MODE_TV;
+    },
+    // RN Android's Platform.isVision is a hard false.
+    get isVision() {
+        return false;
+    },
+    // RN gates this behind __DEV__; shared has no __DEV__ flag, so we read the native
+    // flag directly: a release build's native module reports false anyway.
+    get isTesting() {
+        return resolveConstants()?.isTesting ?? false;
+    },
+    get isDisableAnimations() {
+        const constants = resolveConstants();
+        return constants?.isDisableAnimations ?? constants?.isTesting ?? false;
+    },
+    get isMacCatalyst() {
+        return false;
+    },
+    // RN's exact Android precedence: android -> native -> default.
+    select(spec) {
+        if ('android' in spec)
+            return spec.android;
+        if ('native' in spec)
+            return spec.native;
+        return spec.default;
+    },
+};

package/build/platform/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/platform/index.ios.d.ts

@@ -0,0 +1,18 @@
+import { type IPlatformStatic } from './shared';
+export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic } from './shared';
+export interface IPlatformConstantsIOS {
+    forceTouchAvailable: boolean;
+    interfaceIdiom: string;
+    isTesting: boolean;
+    isDisableAnimations?: boolean;
+    osVersion: string;
+    systemName: string;
+    reactNativeVersion: {
+        major: number;
+        minor: number;
+        patch: number;
+        prerelease?: number | string | null;
+    };
+    isMacCatalyst?: boolean;
+}
+export declare const Platform: IPlatformStatic<IPlatformConstantsIOS>;

package/build/platform/index.ios.js

@@ -0,0 +1,62 @@
+// The iOS Platform: a faithful port of RN's Libraries/Utilities/Platform.ios.js. `OS`
+// is the static 'ios'; everything else derives from the PlatformConstants native module
+// (RN spec NativePlatformConstantsIOS.js), read lazily and cached via the shared
+// resolver. Metro picks this on an iOS host; it is also the base re-export target
+// (platform.ts) so tsc / tsx / web (no Metro) land here too. See .docs/decisions/0022.
+import { createConstantsResolver, UNKNOWN_VERSION, } from './shared';
+// interfaceIdiom values RN compares against for the device-class getters.
+const IDIOM_PAD = 'pad';
+const IDIOM_TV = 'tv';
+const IDIOM_VISION = 'vision';
+// 'ios' is a literal, not a runtime probe: the filename already selected this host.
+const OS_IOS = 'ios';
+function isPlatformConstantsIOS(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'osVersion' in value && 'interfaceIdiom' in value;
+}
+const resolveConstants = createConstantsResolver(isPlatformConstantsIOS);
+function idiomEquals(idiom) {
+    return resolveConstants()?.interfaceIdiom === idiom;
+}
+export const Platform = {
+    OS: OS_IOS,
+    get Version() {
+        return resolveConstants()?.osVersion ?? UNKNOWN_VERSION;
+    },
+    // The whole getConstants() payload (RN exposes it as Platform.constants). May be
+    // undefined headless: RN would have thrown; we return undefined so callers branch.
+    get constants() {
+        return resolveConstants();
+    },
+    get isPad() {
+        return idiomEquals(IDIOM_PAD);
+    },
+    get isTV() {
+        return idiomEquals(IDIOM_TV);
+    },
+    get isVision() {
+        return idiomEquals(IDIOM_VISION);
+    },
+    get isTesting() {
+        return resolveConstants()?.isTesting ?? false;
+    },
+    // RN: isDisableAnimations ?? isTesting. The native flag wins; absent, it tracks
+    // isTesting (test runs disable animations by default).
+    get isDisableAnimations() {
+        const constants = resolveConstants();
+        return constants?.isDisableAnimations ?? constants?.isTesting ?? false;
+    },
+    get isMacCatalyst() {
+        return resolveConstants()?.isMacCatalyst ?? false;
+    },
+    // RN's exact iOS precedence: ios -> native -> default. `in` (not truthiness) so an
+    // explicit `undefined`/`false`/`0` under a present key still wins over default.
+    select(spec) {
+        if ('ios' in spec)
+            return spec.ios;
+        if ('native' in spec)
+            return spec.native;
+        return spec.default;
+    },
+};

package/build/platform/index.js

@@ -0,0 +1,5 @@
+// Base / default Platform: re-exports the iOS implementation. Metro overrides this
+// with platform.ios.ts / platform.android.ts on a real host; under tsc / tsx / web
+// (no Metro) resolution lands here. The filename is the selector, no Platform.OS read.
+// See .docs/decisions/0022 (and 0020 for the same split on component names).
+export * from './index.ios';

package/build/platform/shared.d.ts

@@ -0,0 +1,25 @@
+export declare const PLATFORM_CONSTANTS = "PlatformConstants";
+export declare const UNKNOWN_VERSION = "";
+export type IPlatformOSType = 'ios' | 'android' | 'macos' | 'windows' | 'web' | 'native';
+export type IPlatformSelectSpec<T> = {
+    ios?: T;
+    android?: T;
+    macos?: T;
+    windows?: T;
+    web?: T;
+    native?: T;
+    default?: T;
+};
+export interface IPlatformStatic<TConstants> {
+    readonly OS: IPlatformOSType;
+    readonly Version: string | number;
+    readonly constants: TConstants | undefined;
+    readonly isPad: boolean;
+    readonly isTV: boolean;
+    readonly isVision: boolean;
+    readonly isTesting: boolean;
+    readonly isDisableAnimations: boolean;
+    readonly isMacCatalyst: boolean;
+    select<T>(spec: IPlatformSelectSpec<T>): T | undefined;
+}
+export declare function createConstantsResolver<TConstants>(guard: (value: unknown) => value is TConstants): () => TConstants | undefined;

package/build/platform/shared.js

@@ -0,0 +1,41 @@
+// Shared, platform-neutral Platform bits: the public select/OS types, the static
+// PlatformStatic shape, and the native PlatformConstants resolution machinery: the
+// one place both platform.ios.ts and platform.android.ts pull from. Each platform file
+// owns only what genuinely differs: the OS literal, the constants shape + guard, the
+// select precedence, and the device-class getters. The filename is the selector (Metro
+// picks platform.ios / platform.android by host); no Platform.OS read lives here.
+// See .docs/decisions/0022 (and 0020 for the same split on component names).
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+// The native module name RN registers PlatformConstants under, identical on both
+// platforms; only getConstants()'s SHAPE differs, which each platform file guards.
+export const PLATFORM_CONSTANTS = 'PlatformConstants';
+// Native unresolvable (headless, or a binary without it): RN's getters would throw,
+// but a Platform read must never crash a render, so getters fall back to neutral
+// defaults. '' mirrors iOS "unknown OS version"; Android uses 0 for an unknown API level.
+export const UNKNOWN_VERSION = '';
+// Build a cached getConstants() resolver behind a structural guard. The native payload
+// crosses from an untyped HostObject into TConstants only if `guard` vouches for it (no
+// per-call cast); a failing shape is treated as "module absent". Resolved on first
+// access and cached (RN caches in __constants), re-attempted until valid so a
+// later-installed module is still picked up.
+export function createConstantsResolver(guard) {
+    let cached;
+    return () => {
+        if (cached !== undefined)
+            return cached;
+        const module = getNativeModule(PLATFORM_CONSTANTS);
+        if (module === null) {
+            dlog('Platform: PlatformConstants not resolvable via native bridge — using defaults');
+            return undefined;
+        }
+        const constants = module.getConstants();
+        if (!guard(constants)) {
+            dlog('Platform: PlatformConstants.getConstants() returned an unexpected shape — using defaults');
+            return undefined;
+        }
+        dlog('Platform: resolved PlatformConstants');
+        cached = constants;
+        return cached;
+    };
+}

package/build/platform-color.d.ts

@@ -0,0 +1,19 @@
+export interface IDynamicColorIOSTuple {
+    light: IColorValue;
+    dark: IColorValue;
+    highContrastLight?: IColorValue;
+    highContrastDark?: IColorValue;
+}
+export interface IOpaqueColorValue {
+    readonly semantic?: readonly string[];
+    readonly dynamic?: {
+        readonly light: IColorValue;
+        readonly dark: IColorValue;
+        readonly highContrastLight?: IColorValue;
+        readonly highContrastDark?: IColorValue;
+    };
+}
+export type IColorValue = string | IOpaqueColorValue;
+export declare function PlatformColor(...names: string[]): IOpaqueColorValue;
+export declare function DynamicColorIOS(tuple: IDynamicColorIOSTuple): IOpaqueColorValue;
+export declare function isOpaqueColorValue(value: unknown): value is IOpaqueColorValue;

package/build/platform-color.js

@@ -0,0 +1,25 @@
+// PlatformColor / DynamicColorIOS: opaque color values the native side resolves
+// (iOS UIColor: semantic system colors and appearance-aware light/dark tuples).
+// These are pure object constructors with no native dependency, so they live in
+// shared and every adapter re-exports them. The opaque shape ({ semantic } /
+// { dynamic }) is exactly what RN's processColor and the iOS RCTConvert UIColor
+// path read, so our commit-time color seam routes these objects through the
+// injected processor just like CSS-string colors (see commit.ts processValue).
+export function PlatformColor(...names) {
+    return { semantic: names };
+}
+export function DynamicColorIOS(tuple) {
+    return {
+        dynamic: {
+            light: tuple.light,
+            dark: tuple.dark,
+            highContrastLight: tuple.highContrastLight,
+            highContrastDark: tuple.highContrastDark,
+        },
+    };
+}
+// True for the opaque objects above: the color seam uses this to route them
+// through the platform processor alongside CSS-string colors.
+export function isOpaqueColorValue(value) {
+    return typeof value === 'object' && value !== null && ('semantic' in value || 'dynamic' in value);
+}

package/build/post-commit.d.ts

@@ -0,0 +1,4 @@
+type IPostCommitHook = () => void;
+export declare function registerPostCommit(hook: IPostCommitHook): void;
+export declare function runPostCommitHooks(): void;
+export {};

package/build/post-commit.js

@@ -0,0 +1,16 @@
+// Post-commit hooks: run once after every native commit that changed the tree (after
+// completeRoot, when fresh Fabric tags have just been assigned). The seam exists so a
+// consumer that needs a node's committed tag — today only the Animated native driver,
+// which binds a props node to a view tag — can retry work that ran too early under an
+// async-batched commit (Vue/Svelte schedule completeRoot on a microtask, so lifecycle
+// code can reach a node before its tag exists; React commits synchronously and never
+// queues). A neutral module so commit.ts and animated/props.ts share it without a
+// dependency cycle.
+const hooks = new Set();
+export function registerPostCommit(hook) {
+    hooks.add(hook);
+}
+export function runPostCommitHooks() {
+    for (const hook of hooks)
+        hook();
+}

package/build/process-aspect-ratio.d.ts

@@ -0,0 +1 @@
+export declare function processAspectRatio(aspectRatio: number | string | undefined): number | undefined;

package/build/process-aspect-ratio.js

@@ -0,0 +1,34 @@
+// JS-side port of RN's processAspectRatio (Libraries/StyleSheet/processAspectRatio.js).
+// Same root cause family as boxShadow/filter: RN registers `aspectRatio` with a JS
+// `process` because enableNativeCSSParsing() defaults to false, so the CSS ratio string
+// ('16 / 9') is resolved to a number IN JS before native. A plain number (the common,
+// already-working form) passes through untouched; this is a no-op for it.
+//
+// RN throws via invariant() in __DEV__ on a malformed value; we dlog and return undefined.
+import { dlog } from './debug';
+// RN processAspectRatio.js:15-63. number → number; ratio string → number; invalid → undefined.
+export function processAspectRatio(aspectRatio) {
+    if (typeof aspectRatio === 'number') {
+        return aspectRatio;
+    }
+    if (typeof aspectRatio !== 'string') {
+        if (aspectRatio != null) {
+            dlog(`processAspectRatio reject: must be a number, ratio string or "auto"`);
+        }
+        return undefined;
+    }
+    const matches = aspectRatio.split('/').map(s => s.trim());
+    // RN processAspectRatio.js:34-43: `auto` (and `auto <ratio>`) is not a numeric ratio.
+    if (matches.includes('auto')) {
+        return undefined;
+    }
+    const hasNonNumericValues = matches.some(n => Number.isNaN(Number(n)));
+    if (hasNonNumericValues || (matches.length !== 1 && matches.length !== 2)) {
+        dlog(`processAspectRatio reject: invalid ratio string "${aspectRatio}"`);
+        return undefined;
+    }
+    if (matches.length === 2) {
+        return Number(matches[0]) / Number(matches[1]);
+    }
+    return Number(matches[0]);
+}

package/build/process-background-image/index.d.ts

@@ -0,0 +1,28 @@
+import type { IRadialGradientPosition, IRadialGradientShape, IRadialGradientSize } from '../styles';
+type ILinearGradientDirection = {
+    type: 'angle';
+    value: number;
+} | {
+    type: 'keyword';
+    value: string;
+};
+export type IParsedColorStop = {
+    color: unknown;
+    position: number | string | null;
+};
+export type IParsedLinearGradient = {
+    type: 'linear-gradient';
+    direction: ILinearGradientDirection;
+    colorStops: ReadonlyArray<IParsedColorStop>;
+};
+export type IParsedRadialGradient = {
+    type: 'radial-gradient';
+    shape: IRadialGradientShape;
+    size: IRadialGradientSize;
+    position: IRadialGradientPosition;
+    colorStops: ReadonlyArray<IParsedColorStop>;
+};
+export type IParsedBackgroundImage = IParsedLinearGradient | IParsedRadialGradient;
+type IRawBackgroundImage = Record<string, unknown>;
+export declare function processBackgroundImage(backgroundImage: ReadonlyArray<IRawBackgroundImage> | string | undefined): IParsedBackgroundImage[];
+export type { IRawBackgroundImage };