@symbiote-native/engine 0.1.7 → 0.3.0

package/build/layout-animation/index.js

@@ -42,7 +42,7 @@ const ANIMATION_PROPERTY = {
 // (`FabricUIManager?.configureNextLayoutAnimation` in LayoutAnimation.js) before
 // calling it, no `as` cast needed.
 function hasConfigureNextLayoutAnimation(value) {
-    return isRecord(value) && typeof value.configureNextLayoutAnimation === 'function';
+    return (isRecord(value) && typeof value.configureNextLayoutAnimation === 'function');
 }
 // Resolved FRESH on every configureNext, deliberately NOT memoized. Either mechanism can
 // come and go at runtime (the Fabric global installs during bootstrap; a TurboModule can be
@@ -93,9 +93,15 @@ const Presets = {
     linear: createLayoutAnimation(PRESET_DURATION.linear, ANIMATION_TYPE.linear, ANIMATION_PROPERTY.opacity),
     spring: {
         duration: PRESET_DURATION.spring,
-        create: { type: ANIMATION_TYPE.linear, property: ANIMATION_PROPERTY.opacity },
+        create: {
+            type: ANIMATION_TYPE.linear,
+            property: ANIMATION_PROPERTY.opacity,
+        },
         update: { type: ANIMATION_TYPE.spring, springDamping: SPRING_DAMPING },
-        delete: { type: ANIMATION_TYPE.linear, property: ANIMATION_PROPERTY.opacity },
+        delete: {
+            type: ANIMATION_TYPE.linear,
+            property: ANIMATION_PROPERTY.opacity,
+        },
     },
 };
 // ---- enabled gate --------------------------------------------------------
@@ -148,14 +154,15 @@ function configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
         onAnimationDidEnd?.();
     };
     dlog(`LayoutAnimation.configureNext: dispatching config (duration=${config.duration})`);
-    // Default to a no-op when the caller doesn't supply one.
     manager.configureNextLayoutAnimation(config, onComplete, onAnimationDidFail ?? (() => { }));
 }
 // ---- the LayoutAnimation facade ------------------------------------------
 class LayoutAnimationImpl {
     // Frozen so callers can't mutate the shared type/property tables.
     Types = Object.freeze({ ...ANIMATION_TYPE });
-    Properties = Object.freeze({ ...ANIMATION_PROPERTY });
+    Properties = Object.freeze({
+        ...ANIMATION_PROPERTY,
+    });
     Presets = Presets;
     // Methods (not class fields) so they stay overridable under
     // useDefineForClassFields.

package/build/native-events.js

@@ -70,7 +70,8 @@ export function setDeviceEventSource(source) {
 // would throw "undefined is not a function" — the `?.` guards the module, not a
 // missing method. Mirrors RN's NativeEventEmitter constructor probe.
 function hasObserveCounters(module) {
-    return typeof module.addListener === 'function' && typeof module.removeListeners === 'function';
+    return (typeof module.addListener === 'function' &&
+        typeof module.removeListeners === 'function');
 }
 // Subscribe to events for one native module. Mirrors RN's NativeEventEmitter: each
 // `addListener` also pings the module's `addListener` counter, and removal pings

package/build/native-modules/index.js

@@ -110,7 +110,9 @@ export function createDeviceEventModule(config) {
             installDeviceEventHub();
             const resolved = getModule();
             const bindModule = config.bindModuleToEmitter ?? true;
-            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved) ? resolved : undefined;
+            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved)
+                ? resolved
+                : undefined;
             emitter = new NativeEventEmitter(boundModule);
             config.onEmitterCreated?.(emitter, resolved);
         }

package/build/node.d.ts

@@ -19,6 +19,7 @@ export interface ISymbioteNode {
     listeners: Map<string, IListener> | undefined;
     children: ISymbioteNode[];
     parent: ISymbioteNode | undefined;
+    dirty: boolean;
 }
 export declare function createElement(component: string, isText?: boolean): ISymbioteNode;
 export declare function createRawText(text: string): ISymbioteNode;
@@ -27,12 +28,36 @@ export declare function debugNodeId(node: ISymbioteNode): number;
 export declare const ANCHOR_COMPONENT = "#anchor";
 export declare function createAnchor(): ISymbioteNode;
 export declare function isAnchor(node: ISymbioteNode): boolean;
+export declare function isEmptyRawText(node: ISymbioteNode): boolean;
+export declare function markDirty(node: ISymbioteNode): void;
+export declare function takePropStats(): {
+    writes: number;
+    noops: number;
+};
 export declare function setProp(node: ISymbioteNode, key: string, value: unknown): void;
 export declare function setEventListener(node: ISymbioteNode, name: string, value: unknown): void;
+/**
+ * Stop a node painting without unmounting it, or let it paint again.
+ *
+ * The seam React's `Activity`/`Suspense` reach for through `hideInstance`/`unhideInstance`. It
+ * lives in the engine rather than an adapter because the reversibility problem — restoring the
+ * author's style byte for byte — belongs to whoever owns the style merge, and that is here.
+ */
+export declare function setNodeHidden(node: ISymbioteNode, hidden: boolean): void;
 export declare function getExplicitStyle(node: ISymbioteNode): unknown;
 export declare function routeProp(node: ISymbioteNode, key: string, value: unknown): void;
 export declare function setText(node: ISymbioteNode, text: string): void;
 export declare function appendChild(parent: ISymbioteNode, child: ISymbioteNode): void;
 export declare function insertBefore(parent: ISymbioteNode, child: ISymbioteNode, beforeChild: ISymbioteNode): void;
 export declare function removeChild(parent: ISymbioteNode, child: ISymbioteNode): void;
+export interface ITreeCensus {
+    nodes: number;
+    anchors: number;
+    emptyRawTexts: number;
+    /** Nodes the commit walk actually reconciles: `nodes` minus everything it skips. */
+    renderable: number;
+    /** children.length of every parent holding at least one skipped child, widest first. */
+    flattenWidths: number[];
+}
+export declare function censusRetainedTree(roots: readonly ISymbioteNode[]): ITreeCensus;
 export {};

package/build/node.js

@@ -34,6 +34,7 @@ export function createElement(component, isText = false) {
         listeners: undefined,
         children: [],
         parent: undefined,
+        dirty: true,
     };
 }
 export function createRawText(text) {
@@ -45,6 +46,7 @@ export function createRawText(text) {
         listeners: undefined,
         children: [],
         parent: undefined,
+        dirty: true,
     };
 }
 // `instanceHandle` round-trips through Fabric unchanged: the object we pass to
@@ -80,16 +82,97 @@ export function createAnchor() {
 export function isAnchor(node) {
     return node.component === ANCHOR_COMPONENT;
 }
+// A raw text with no characters must not reach Fabric. Its fragment is dropped by
+// AttributedString::appendFragment, but the text walk has already flagged "the last child was raw
+// text", so the NEXT raw sibling merges into `fragments.back()` of an empty vector and the process
+// aborts. The commit walk skips such a node exactly as it skips an anchor (commit.ts,
+// renderableChildren); an empty string paints nothing either way, so nothing is lost. `''` only —
+// a whitespace-only string is real content inside a <Text>.
+export function isEmptyRawText(node) {
+    return node.component === RAW_TEXT_COMPONENT && node.props.text === '';
+}
+// Dirty-marking: lets reconcile return an untouched subtree by reference instead of rebuilding
+// every node's Fabric props and deep-comparing them against the mirror. That walk costs ~13 us per
+// node on device (Hermes, iOS Debug, examples/react benchmark screen), so without the flag a
+// 1200-node tree burns a whole 16.6 ms frame no matter how small the change - the cost tracks TREE
+// SIZE, not change size.
+//
+// Marking walks up to the first ALREADY-dirty ancestor and stops, so a burst of mutations under one
+// subtree pays for one chain walk rather than one per mutation. Reconcile clears every node it
+// visits, which keeps the invariant "an ancestor of a dirty node is dirty" across commits.
+//
+// Listener changes deliberately do NOT mark. `node.listeners` never reaches Fabric (event dispatch
+// reads it straight off the retained node) and React hands us a fresh handler closure on nearly
+// every render, so marking there would re-dirty the whole tree every commit and hand the win back.
+// The one listener that DOES change a Fabric prop, `layout`, raises `onLayout` through setProp
+// below and is marked that way.
+export function markDirty(node) {
+    let current = node;
+    while (current !== undefined && !current.dirty) {
+        current.dirty = true;
+        current = current.parent;
+    }
+}
+// How many prop writes actually landed, and how many the no-op guard below turned away.
+// Read-and-zeroed through readCommitProfile() (commit.ts), which folds them into the same window
+// as the walk numbers so one read prices both halves: `propNoops` is the waste an adapter is
+// generating above the engine, `nodesVisited` is what that waste costs below it.
+//
+// Not gated behind isDebug(), for the same reason the commit profile is not: an integer increment
+// is noise next to the prop write it counts, and the figure is only meaningful from a release
+// build. A per-call dlog was the obvious alternative and is deliberately NOT here - the Angular
+// screen that motivated the guard emitted 90 000 no-op writes on one press, and a log line each
+// would measure the logging rather than the code (see the `perf-claims-need-numbers` rule).
+const propStats = { writes: 0, noops: 0 };
+export function takePropStats() {
+    const snapshot = { writes: propStats.writes, noops: propStats.noops };
+    propStats.writes = 0;
+    propStats.noops = 0;
+    return snapshot;
+}
 // A pure prop set: no event inference. `onTintColor` is a Switch prop and reaches
 // Fabric like any other; the event-vs-prop decision is made by routeProp, never by
 // the key's name.
+//
+// Writing a value the node already holds is a NO-OP and returns before markDirty. Fabric never saw
+// a difference either way - reconcile rebuilds the node's Fabric props and `propsEqual` finds them
+// identical, so no clone is emitted - but the mark itself is not free: it walks to the first
+// already-dirty ancestor and strips every one of them of the commit walk's early exit, so an
+// otherwise untouched subtree gets re-walked purely to prove it is untouched. The guard makes that
+// whole bug class free for every adapter instead of each one having to remember to diff first
+// (measured: Angular's Pressable host bag pushed 104 000 setProp calls for a screen Solid built in
+// 12 000, 90 000 of them writing `undefined` over a key that was not there).
+//
+// Three deliberate choices:
+//
+// - `Object.hasOwn`, not `node.props[key] === undefined`. A key explicitly present holding
+//   `undefined` is not an absent key: `delete` genuinely changes the record's shape, and
+//   `setNativeProps` writes node.props directly and can leave exactly such a key behind. Fabric
+//   itself cannot tell the two apart (fabricProps skips undefined values), but node.props is also
+//   read outside the commit path, so the retained tree keeps the shape callers asked for.
+// - `Object.is`, not a deep compare. A style object, an array, or a handler closure is a fresh
+//   reference on nearly every render, so the guard simply never fires for them - correct, since an
+//   adapter is free to hand back the SAME reference with mutated contents and identity cannot see
+//   that. A deep compare on every prop write would cost more than the walk it saves.
+// - The in-place-mutation hazard that leaves is already instrumented: a node skipped as clean whose
+//   props have drifted is exactly what `warnIfStale` reports as DIRTY-MISS under DEBUG (commit.ts).
 export function setProp(node, key, value) {
     if (value === undefined) {
+        if (!Object.hasOwn(node.props, key)) {
+            propStats.noops += 1;
+            return;
+        }
         delete node.props[key];
     }
     else {
+        if (Object.is(node.props[key], value)) {
+            propStats.noops += 1;
+            return;
+        }
         node.props[key] = value;
     }
+    propStats.writes += 1;
+    markDirty(node);
 }
 // Fabric gates layout events behind a boolean prop (BaseViewProps.onLayout): unlike
 // scroll / touch / change, which the native component emits unconditionally, a
@@ -148,12 +231,41 @@ const RESPONDER_EVENTS = new Set([
 // dynamic" (the instance holds functions) and the surface paints black, while iOS silently
 // drops it. SFC/template authoring never produces them. Strip them here, once, so no
 // adapter leaks React JSX dev metadata to the host, mirroring React's host config.
-const REACT_JSX_DEV_PROPS = new Set(['__self', '__source']);
+const REACT_JSX_DEV_PROPS = new Set([
+    '__self',
+    '__source',
+]);
 const classStyleParts = new WeakMap();
+// The fresh array below means setProp's no-op guard never fires for `style`, and that is
+// DELIBERATE - do not "finish the optimization" by skipping when both halves are unchanged.
+// `classStyleParts` is a shadow copy of the declarative style, and setNativeProps bypasses it
+// (it writes node.props.style directly, merging an Animated frame onto whatever is there). An
+// app that hands over a hoisted style constant - StyleSheet.create, a module-level object - would
+// then re-push an identity-equal half, get skipped, and never restore the declarative style the
+// animation overwrote. The re-push IS the restore path.
 function commitClassStyle(node, patch) {
     const entry = { ...classStyleParts.get(node), ...patch };
     classStyleParts.set(node, entry);
-    setProp(node, 'style', [entry.classStyle, entry.explicitStyle]);
+    // The third slot is APPENDED ONLY WHILE HIDDEN. Writing a permanent three-element array would
+    // change the style payload of every node in every app for a state almost none of them are ever
+    // in — and this project spent a day removing per-frame allocations, so a slot that is undefined
+    // 99.9% of the time does not get to ride along on every style write.
+    setProp(node, 'style', entry.hiddenStyle === undefined
+        ? [entry.classStyle, entry.explicitStyle]
+        : [entry.classStyle, entry.explicitStyle, entry.hiddenStyle]);
+}
+// `display: 'none'` is a real RN style value (Yoga's DisplayNone), so a hidden node keeps its
+// place in the tree, its state and its children — it just stops laying out and painting.
+const HIDDEN_STYLE = { display: 'none' };
+/**
+ * Stop a node painting without unmounting it, or let it paint again.
+ *
+ * The seam React's `Activity`/`Suspense` reach for through `hideInstance`/`unhideInstance`. It
+ * lives in the engine rather than an adapter because the reversibility problem — restoring the
+ * author's style byte for byte — belongs to whoever owns the style merge, and that is here.
+ */
+export function setNodeHidden(node, hidden) {
+    commitClassStyle(node, { hiddenStyle: hidden ? HIDDEN_STYLE : undefined });
 }
 // The explicit (non-class-derived) style half, for an adapter that builds its style prop up
 // key-by-key (Angular's Ivy ɵɵstyleProp/setStyle) instead of handing over one whole object —
@@ -199,9 +311,29 @@ export function routeProp(node, key, value) {
     }
     setProp(node, key, value);
 }
+// The same no-op guard as setProp, and here it is strictly stronger: `text` is a string, so
+// `Object.is` is a real value comparison rather than the reference check it degrades to for a style
+// object or a handler. A framework that re-renders a subtree and hands back an unchanged label -
+// every list row whose text did not move, on every update - stops stripping its ancestors of the
+// commit walk's early exit. Counted in the same propStats, because a text write IS a prop write:
+// it lands in node.props.text and reaches Fabric as RCTRawText's only prop.
+//
+// Safe against the one ordering hazard worth naming: a raw-text node REPARENTED under a <Text>
+// commits as RCTVirtualText instead of RCTText (viewNameFor, commit.ts). That flip is not driven
+// from here - a structural op marks the parent chain, and reconcile re-checks `committed.parent` on
+// its early-exit path - so a same-text write not marking cannot hide it.
 export function setText(node, text) {
+    if (Object.is(node.props.text, text)) {
+        propStats.noops += 1;
+        return;
+    }
     node.props.text = text;
+    propStats.writes += 1;
+    markDirty(node);
 }
+// Structural ops mark the PARENT chain (both the old and the new one), never the moved child:
+// a child that only changed position may legitimately still be clean, and reconcile re-checks
+// `committed.parent` on its early-exit path, so a reparent is caught there rather than by a flag.
 function detach(child) {
     const parent = child.parent;
     if (!parent)
@@ -210,21 +342,55 @@ function detach(child) {
     if (index >= 0)
         parent.children.splice(index, 1);
     child.parent = undefined;
+    markDirty(parent);
 }
 export function appendChild(parent, child) {
     detach(child);
     child.parent = parent;
     parent.children.push(child);
+    markDirty(parent);
 }
 export function insertBefore(parent, child, beforeChild) {
     detach(child);
     child.parent = parent;
     const index = parent.children.indexOf(beforeChild);
     parent.children.splice(index < 0 ? parent.children.length : index, 0, child);
+    markDirty(parent);
 }
 export function removeChild(parent, child) {
     const index = parent.children.indexOf(child);
     if (index >= 0)
         parent.children.splice(index, 1);
     child.parent = undefined;
+    markDirty(parent);
+}
+export function censusRetainedTree(roots) {
+    const census = {
+        nodes: 0,
+        anchors: 0,
+        emptyRawTexts: 0,
+        renderable: 0,
+        flattenWidths: [],
+    };
+    // Explicit stack, not recursion: a deep list under a benchmark screen would blow the JS stack
+    // on the very tree this is meant to measure.
+    const stack = [...roots];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        census.nodes += 1;
+        if (isAnchor(node))
+            census.anchors += 1;
+        else if (isEmptyRawText(node))
+            census.emptyRawTexts += 1;
+        else
+            census.renderable += 1;
+        if (node.children.some(child => isAnchor(child) || isEmptyRawText(child)))
+            census.flattenWidths.push(node.children.length);
+        for (const child of node.children)
+            stack.push(child);
+    }
+    census.flattenWidths.sort((left, right) => right - left);
+    return census;
 }

package/build/pan-responder/index.js

@@ -17,7 +17,9 @@ const SINGLE_TOUCH_COUNT = 1;
 // onShouldBlockNativeResponder defaults to true (RN: block native by default).
 const DEFAULT_BLOCK_NATIVE_RESPONDER = true;
 function toFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    return typeof value === 'number' && Number.isFinite(value)
+        ? value
+        : undefined;
 }
 // Pull one touch out of an untyped array element, skipping anything that does not
 // carry numeric pageX/pageY. `timestamp` falls back to 0 when absent so a touch
@@ -196,7 +198,7 @@ function initializeGestureState(gestureState) {
 // The timestamp this frame advances to: the touch-history clock when shared attached a
 // store, else the most recent of the live touches (headless direct-call path).
 function frameTimestampOf(event, touches) {
-    return touchHistoryOf(event)?.mostRecentTimeStamp ?? mostRecentTimestamp(touches);
+    return (touchHistoryOf(event)?.mostRecentTimeStamp ?? mostRecentTimestamp(touches));
 }
 // Advance the gesture for a move frame. With a touch-history store (the device / shared
 // path) this defers to RN's accumulate-per-moved-touch math; without one it falls back to
@@ -275,7 +277,8 @@ const PanResponder = {
                 // Skip a duplicate dispatch of the same frame: when two touches change at
                 // once the responder system fires twice, but the geometry was already
                 // folded in on the first call.
-                if (gestureState._accountsForMovesUpTo === frameTimestampOf(event, touches)) {
+                if (gestureState._accountsForMovesUpTo ===
+                    frameTimestampOf(event, touches)) {
                     return false;
                 }
                 updateGestureStateOnMove(gestureState, event, touches);
@@ -288,14 +291,19 @@ const PanResponder = {
                 const touches = readTouches(event);
                 const touchHistory = touchHistoryOf(event);
                 // x0/y0 is the non-cumulative centroid at grant time (RN: currentCentroid).
-                gestureState.x0 = touchHistory ? currentCentroidXAll(touchHistory) : centroidX(touches);
-                gestureState.y0 = touchHistory ? currentCentroidYAll(touchHistory) : centroidY(touches);
+                gestureState.x0 = touchHistory
+                    ? currentCentroidXAll(touchHistory)
+                    : centroidX(touches);
+                gestureState.y0 = touchHistory
+                    ? currentCentroidYAll(touchHistory)
+                    : centroidY(touches);
                 gestureState.dx = 0;
                 gestureState.dy = 0;
                 // The grant frame is already accounted for, so the first move's velocity
                 // is measured from here, not from time 0.
                 gestureState._accountsForMovesUpTo = frameTimestampOf(event, touches);
-                gestureState.numberActiveTouches = touchHistory?.numberActiveTouches ?? touches.length;
+                gestureState.numberActiveTouches =
+                    touchHistory?.numberActiveTouches ?? touches.length;
                 config.onPanResponderGrant?.(event, gestureState);
                 return config.onShouldBlockNativeResponder === undefined
                     ? DEFAULT_BLOCK_NATIVE_RESPONDER
@@ -306,13 +314,15 @@ const PanResponder = {
             },
             onResponderStart(event) {
                 gestureState.numberActiveTouches =
-                    touchHistoryOf(event)?.numberActiveTouches ?? readTouches(event).length;
+                    touchHistoryOf(event)?.numberActiveTouches ??
+                        readTouches(event).length;
                 config.onPanResponderStart?.(event, gestureState);
             },
             onResponderMove(event) {
                 const touches = readTouches(event);
                 // Same duplicate-frame guard as the capture path.
-                if (gestureState._accountsForMovesUpTo === frameTimestampOf(event, touches)) {
+                if (gestureState._accountsForMovesUpTo ===
+                    frameTimestampOf(event, touches)) {
                     return;
                 }
                 updateGestureStateOnMove(gestureState, event, touches);
@@ -320,7 +330,8 @@ const PanResponder = {
             },
             onResponderEnd(event) {
                 gestureState.numberActiveTouches =
-                    touchHistoryOf(event)?.numberActiveTouches ?? readTouches(event).length;
+                    touchHistoryOf(event)?.numberActiveTouches ??
+                        readTouches(event).length;
                 config.onPanResponderEnd?.(event, gestureState);
             },
             onResponderRelease(event) {

package/build/permissions-android/index.js

@@ -84,7 +84,9 @@ export const PERMISSIONS = Object.freeze({
 // string is passed through as a IPermissionStatus only when it matches; otherwise
 // we fall back to DENIED: a runtime guard at the trust boundary, not an `as`.
 function toPermissionStatus(value) {
-    if (value === RESULTS.GRANTED || value === RESULTS.DENIED || value === RESULTS.NEVER_ASK_AGAIN) {
+    if (value === RESULTS.GRANTED ||
+        value === RESULTS.DENIED ||
+        value === RESULTS.NEVER_ASK_AGAIN) {
         return value;
     }
     return RESULTS.DENIED;

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

@@ -1,5 +1,5 @@
 import { type IPlatformStatic } from './shared';
-export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic } from './shared';
+export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic, } from './shared';
 export interface IPlatformConstantsAndroid {
     isTesting: boolean;
     isDisableAnimations?: boolean;

package/build/platform/index.android.js

@@ -3,7 +3,7 @@
 // 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.
-import { createConstantsResolver } from './shared.js';
+import { createConstantsResolver, } from './shared.js';
 // The filename already selected this host: 'android' is a literal, not a probe.
 const OS_ANDROID = 'android';
 // RN reads isTV off the uiMode constant.

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

@@ -1,5 +1,5 @@
 import { type IPlatformStatic } from './shared';
-export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic } from './shared';
+export type { IPlatformOSType, IPlatformSelectSpec, IPlatformStatic, } from './shared';
 export interface IPlatformConstantsIOS {
     forceTouchAvailable: boolean;
     interfaceIdiom: string;

package/build/platform-color/index.js

@@ -21,7 +21,9 @@ export function DynamicColorIOS(tuple) {
 // 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);
+    return (typeof value === 'object' &&
+        value !== null &&
+        ('semantic' in value || 'dynamic' in value));
 }
 // Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++ color
 // parser silently drops strings. The actual conversion (processColor) is RN-platform-specific,

package/build/post-commit.d.ts

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

package/build/post-commit.js

@@ -10,6 +10,12 @@ const hooks = new Set();
 export function registerPostCommit(hook) {
     hooks.add(hook);
 }
+// The counterpart, needed the moment a hook belongs to something with a lifetime (a screen, a
+// component) rather than to the process. Without it a mounted-and-gone consumer keeps running
+// after every commit forever, holding its whole closure alive.
+export function unregisterPostCommit(hook) {
+    hooks.delete(hook);
+}
 export function runPostCommitHooks() {
     for (const hook of hooks)
         hook();

package/build/process-background-image/index.js

@@ -15,16 +15,23 @@ const COLOR_STOP_PARTS_REGEX = /\S+\([^)]*\)|\S+/g;
 const WHITESPACE_NORMALIZE_REGEX = /\s+/g;
 const LINEAR_GRADIENT_DIRECTION_REGEX = /^to\s+(?:top|bottom|left|right)(?:\s+(?:top|bottom|left|right))?/i;
 const LINEAR_GRADIENT_ANGLE_UNIT_REGEX = /^([+-]?\d*\.?\d+)(deg|grad|rad|turn)$/i;
-const LINEAR_GRADIENT_DEFAULT_DIRECTION = { type: 'angle', value: 180 };
+const LINEAR_GRADIENT_DEFAULT_DIRECTION = {
+    type: 'angle',
+    value: 180,
+};
 const DEFAULT_RADIAL_SHAPE = 'ellipse';
 const DEFAULT_RADIAL_SIZE = 'farthest-corner';
-const DEFAULT_RADIAL_POSITION = { top: '50%', left: '50%' };
+const DEFAULT_RADIAL_POSITION = {
+    top: '50%',
+    left: '50%',
+};
 function isStringOrNumber(value) {
     return typeof value === 'string' || typeof value === 'number';
 }
 // A color-stop position is a plain px number or a percentage string; anything else is invalid.
 function isPositionValue(value) {
-    return typeof value === 'number' || (typeof value === 'string' && value.endsWith('%'));
+    return (typeof value === 'number' ||
+        (typeof value === 'string' && value.endsWith('%')));
 }
 // A gradient color may already be a platform int (array form) or a CSS string/PlatformColor
 // object needing processColor; mirrors process-box-shadow's processShadowColor.
@@ -63,7 +70,9 @@ function getAngleInDegrees(angle) {
     }
 }
 function getDirectionForKeyword(direction) {
-    const normalized = direction.replace(WHITESPACE_NORMALIZE_REGEX, ' ').toLowerCase();
+    const normalized = direction
+        .replace(WHITESPACE_NORMALIZE_REGEX, ' ')
+        .toLowerCase();
     switch (normalized) {
         case 'to top':
             return { type: 'angle', value: 0 };
@@ -106,7 +115,9 @@ function resolveRadialSize(value) {
         value === 'farthest-corner') {
         return value;
     }
-    if (isRecord(value) && isStringOrNumber(value.x) && isStringOrNumber(value.y)) {
+    if (isRecord(value) &&
+        isStringOrNumber(value.x) &&
+        isStringOrNumber(value.y)) {
         return { x: value.x, y: value.y };
     }
     return null;
@@ -129,7 +140,9 @@ function processColorStopsArray(rawColorStops) {
             return null;
         const positions = rawStop.positions;
         // Color transition hint syntax (`red, 20%, blue`): a position with no color of its own.
-        if (rawStop.color == null && Array.isArray(positions) && positions.length === 1) {
+        if (rawStop.color == null &&
+            Array.isArray(positions) &&
+            positions.length === 1) {
             const position = positions[0];
             if (!isPositionValue(position))
                 return null;
@@ -205,7 +218,13 @@ function processBackgroundImageArray(rawList) {
             const position = isRadialPositionValue(rawBgImage.position)
                 ? rawBgImage.position
                 : DEFAULT_RADIAL_POSITION;
-            result.push({ type: 'radial-gradient', shape, size, position, colorStops });
+            result.push({
+                type: 'radial-gradient',
+                shape,
+                size,
+                position,
+                colorStops,
+            });
         }
     }
     return result;
@@ -365,11 +384,13 @@ function parseRadialGradientPositionTokens(tokens) {
         const token2 = t2.toLowerCase().trim();
         const horizontalPositions = ['left', 'center', 'right'];
         const verticalPositions = ['top', 'center', 'bottom'];
-        if (horizontalPositions.includes(token1) && verticalPositions.includes(token2)) {
+        if (horizontalPositions.includes(token1) &&
+            verticalPositions.includes(token2)) {
             left = token1 === 'left' ? '0%' : token1 === 'center' ? '50%' : '100%';
             top = token2 === 'top' ? '0%' : token2 === 'center' ? '50%' : '100%';
         }
-        else if (verticalPositions.includes(token1) && horizontalPositions.includes(token2)) {
+        else if (verticalPositions.includes(token1) &&
+            horizontalPositions.includes(token2)) {
             left = token2 === 'left' ? '0%' : token2 === 'center' ? '50%' : '100%';
             top = token1 === 'top' ? '0%' : token1 === 'center' ? '50%' : '100%';
         }

package/build/process-filter.js

@@ -74,7 +74,9 @@ export function processFilter(filter) {
         for (const filterFunction of filter) {
             const [filterName, filterValue] = Object.entries(filterFunction)[0];
             if (filterName === 'dropShadow') {
-                const dropShadow = isDropShadowValue(filterValue) ? parseDropShadow(filterValue) : null;
+                const dropShadow = isDropShadowValue(filterValue)
+                    ? parseDropShadow(filterValue)
+                    : null;
                 if (dropShadow == null) {
                     dlog(`processFilter reject: invalid dropShadow in array`);
                     return [];
@@ -154,7 +156,9 @@ function getFilterAmount(filterName, filterArgs) {
             if (unit !== 'deg' && unit !== 'rad') {
                 return undefined;
             }
-            return unit === 'rad' ? RADIANS_TO_DEGREES * filterArgAsNumber : filterArgAsNumber;
+            return unit === 'rad'
+                ? RADIANS_TO_DEGREES * filterArgAsNumber
+                : filterArgAsNumber;
         // blur takes any non-negative CSS length that is not a percent; RN only has DIPs.
         case 'blur':
             if ((unit != null && unit !== 'px') || filterArgAsNumber < 0) {
@@ -169,7 +173,8 @@ function getFilterAmount(filterName, filterArgs) {
         case 'opacity':
         case 'saturate':
         case 'sepia':
-            if ((unit != null && unit !== '%' && unit !== 'px') || filterArgAsNumber < 0) {
+            if ((unit != null && unit !== '%' && unit !== 'px') ||
+                filterArgAsNumber < 0) {
                 return undefined;
             }
             return unit === '%' ? filterArgAsNumber / 100 : filterArgAsNumber;
@@ -179,7 +184,9 @@ function getFilterAmount(filterName, filterArgs) {
 }
 // RN processFilter.js:188-256.
 function parseDropShadow(rawDropShadow) {
-    const dropShadow = typeof rawDropShadow === 'string' ? parseDropShadowString(rawDropShadow) : rawDropShadow;
+    const dropShadow = typeof rawDropShadow === 'string'
+        ? parseDropShadowString(rawDropShadow)
+        : rawDropShadow;
     if (dropShadow == null) {
         return null;
     }

package/build/process-font-variant.js

@@ -12,6 +12,5 @@ export function processFontVariant(fontVariant) {
     if (typeof fontVariant === 'string') {
         return fontVariant.split(' ').filter(Boolean);
     }
-    // Neither an array nor a string: nothing to split, hand back an empty variant list.
     return [];
 }