@ng-native/fabric 0.12.0 → 0.14.0

package/dist/engine.d.ts

@@ -186,8 +186,8 @@ interface Committed {
 export interface EngineNode extends HostNode {
     readonly kind: NodeKind;
     /** Lowercase template spelling, e.g. `view`. Never the native view name. */
-    readonly name: string;
-    /** `name` again, for Angular 22.0, which reads it on a component's host element. */
+    readonly tag: string;
+    /** `tag` again, for Angular 22.0, which reads it on a component's host element. */
     readonly tagName: string;
     props: Record<string, unknown>;
     text: string;
@@ -269,6 +269,14 @@ export interface EngineNode extends HostNode {
     playing?: RunningAnimation;
     /** An animation played by a scroll view's offset rather than the clock. See `scrollAnimated`. */
     scrolled?: ScrollAnimation;
+    /**
+     * The props a native animated graph has set on the view with this tag, which no commit
+     * changes again: see `Touched`. A view made again has another tag, and starts with none.
+     */
+    owned?: {
+        readonly tag: number;
+        readonly keys: Set<string>;
+    };
     /**
      * The last `transform` built from the individual transform properties, and what it was built
      * from. Reused while the parts are the same objects, so an unrelated change does not re-send it.
@@ -403,7 +411,16 @@ export interface ViewNameOptions {
      * element is the engine's own, as the paragraph a view is given for its loose text is.
      */
     readonly looseText?: string;
+    /**
+     * Where a view's own props name a font that must reach native by another name, as SwiftUI's
+     * `font` modifier must name a face by its file's PostScript name: rewrites `props` in place,
+     * given that name for each name the app's `@font-face` faces are registered under. Called on
+     * every commit of the view, and again for each view when the faces change.
+     */
+    readonly fontNames?: (props: Record<string, unknown>, postScriptName: PostScriptNames) => void;
 }
+/** The PostScript name of the face a name is registered under, where the build read it. */
+export type PostScriptNames = (name: string) => string | undefined;
 /**
  * A view whose native name differs by platform. Chosen when the view is looked up rather than when
  * it is registered, so it does not matter which ran first: an app's imports register the router's
@@ -457,6 +474,25 @@ export interface HoistOptions {
      * another, so what the native side sees is one config that is updated, never one that goes.
      */
     standIn?: Record<string, unknown>;
+    /**
+     * Have the ancestor commit the elements hoisted into it and nothing else, in the order they
+     * were written.
+     *
+     * For a native component that takes children of one type only. `RNSScreenStackHeaderConfig`
+     * takes `RNSScreenStackHeaderSubview`s: iOS logs an error and drops any other child, and Android
+     * throws. A header item written inside a component of the header reached it inside that
+     * component's host view.
+     */
+    only?: boolean;
+    /**
+     * Ancestor names the element never hoists past: met before the ancestor it commits into, it
+     * commits where it is, as one with no such ancestor does.
+     *
+     * For an ancestor the target is not meant to reach through. A tab's page with no stack of its
+     * own has no screen of its own, and the screen above its tab is the one that holds the whole
+     * tab bar, so a header written in that page must not configure it.
+     */
+    stopAt?: readonly string[];
 }
 /** A native view an ancestor keeps for a hoisted name with a stand-in, and who it is for now. */
 interface KeptHoist {
@@ -467,7 +503,7 @@ interface KeptHoist {
 /** The part of a node `viewNameOf` reads: an engine node, or any host's mirror of one. */
 export interface ViewNameNode {
     readonly kind: string;
-    readonly name: string;
+    readonly tag: string;
     readonly parent: ViewNameNode | null;
     /** Whether a component is mounted on it, and whether that component is the native view. */
     readonly componentHost?: boolean;
@@ -650,6 +686,8 @@ export declare class Engine implements HostEngine {
      * binding, so nothing marks an Angular view dirty and no change-detection pass would follow.
      */
     private setActiveChain;
+    /** The nodes a press has set `:active` on, to clear whatever happens to the tree meanwhile. */
+    private readonly activeNodes;
     /** Whether any sheet styles a pressed element, and each compound that asks about one from another. */
     private activeUse;
     /** What each sheet in play asks about a pressed element: `activeUse` is all of them together. */
@@ -800,6 +838,20 @@ export declare class Engine implements HostEngine {
      * committed is styled when it is, with the class as it is then.
      */
     private markClasses;
+    /**
+     * How many class changes have restyled what is under an element. `markUnder` walks the tree as
+     * it is, so an element out of it then is not reached: one that comes back after any is matched
+     * again, with all that is under it.
+     */
+    private classesAbove;
+    /**
+     * The count when each element went out of the tree, for the ones still out. `detach` sets it
+     * for a node that only moves too, so `markReturned` runs after it and clears that.
+     */
+    private readonly outSince;
+    /** Have matched again a node coming back into the tree that missed a class change above it. */
+    private markReturned;
+    private markAllUnder;
     /**
      * Have matched again each element under a node that one of `subjects`' rules could be for. One
      * under another is marked too: what is under an element marked this way keeps its rules.
@@ -873,6 +925,13 @@ export declare class Engine implements HostEngine {
      * forgetting walks each subtree that left once.
      */
     private releaseDetached;
+    /** A pressed node out of the tree gets no release: native has no view to end the touch on. */
+    private dropDetachedPress;
+    /**
+     * Forget the focused node, which has left the tree without a blur: off the node as well as the
+     * engine, or a `:focus` rule styles it again when it is put back.
+     */
+    private dropFocus;
     /** Forget the committed views of each node removed since the last commit that is still out. */
     private forgetDetached;
     /** The root of the tree a node is in: the engine's root while it is attached. */
@@ -885,6 +944,18 @@ export declare class Engine implements HostEngine {
     destroyNode(node: EngineNode): void;
     parentNode(node: EngineNode): EngineNode | null;
     nextSibling(node: EngineNode): EngineNode | null;
+    /**
+     * Whether any declaration the engine was given transitions or animates: until one does, a
+     * node's style is committed as it is, with nothing asked of what eases it. See `eased`.
+     */
+    private eases;
+    private noteEasing;
+    /** A node's style as its transitions and animation have it: a declaration asks for one. */
+    private eased;
+    /** Note a sheet any of whose rules transitions or animates: see `eases`. */
+    private noteSheetEasing;
+    /** Note a prop, or a style set as one, that transitions or animates: see `eases`. */
+    private noteEasingProp;
     setProp(node: EngineNode, key: string, value: unknown): void;
     /**
      * Have the paragraph a run of text is in merged again: it is as tall as the tallest line of
@@ -922,11 +993,15 @@ export declare class Engine implements HostEngine {
      */
     styleChanged(node: EngineNode): void;
     /**
-     * A bound declaration, `[style.color]`, whose value may be a `var()`. One that is, is kept as a
-     * declaration the cascade settles with the node's tokens, as a rule's is, and true is answered:
-     * the text is no value to put in the node's style. Any other value forgets what was kept.
+     * A bound declaration, `[style.color]`, whose value may be a `var()`, or a length in `em` or a
+     * viewport unit. One that is, is kept as a declaration the cascade settles with the node's
+     * tokens, font size and viewport, as a rule's is, and true is answered: the text is no value to
+     * put in the node's style. A negative `line-height` is dropped, with a warning, and true is
+     * answered too. Any other value forgets what was kept.
      */
     setBoundStyle(node: EngineNode, prop: string, value: unknown): boolean;
+    /** Whether a bound value is one CSS has none of, which is dropped with a warning. */
+    private refusedBound;
     /**
      * Set a custom property on a node, `--tint` from `[style.--tint]`, or remove it with `null`.
      *
@@ -1007,6 +1082,9 @@ export declare class Engine implements HostEngine {
      * optimisation.
      */
     commit(): boolean;
+    /** A field went out of view focused, in the commit running: see `undisplayed`. */
+    private blurAfterCommit;
+    private blurHidden;
     private beforeCommit;
     private announceCommit;
     /**
@@ -1193,6 +1271,7 @@ export declare class Engine implements HostEngine {
     private markAnimated;
     /** Every `@font-face` seen, global as on the web: a face declared in one sheet serves all. */
     private readonly fontFaces;
+    private readonly postScriptName;
     /** Whether a sheet first used in this commit declared a face. See `rematchFonts`. */
     private facesAdded;
     /**
@@ -1273,10 +1352,24 @@ export declare class Engine implements HostEngine {
     private playNatively;
     /**
      * Native reached the end of an animation it was playing. The frame it ends at, or the resting
-     * style where it does not fill, is committed before the view is let go, so nothing shows of
-     * the frame it started at, which is what the view had been committed with.
+     * style where it does not fill, is committed, and set on native where the animation set the
+     * prop (see `setOwned`). The view is let go first, which puts nothing back on Fabric: it is
+     * drawn where the animation left it until then.
      */
     private endedNatively;
+    /** A graph of native's was connected to a view: see `Touched`. */
+    private touchedNatively;
+    /**
+     * Set on native a change of a prop a graph of native's has set on the view before, while no
+     * graph of its holds it: the commit cannot change it (see `Touched`). The payload is committed
+     * as well, so the shadow node is as the view is drawn. A transform native cannot take as
+     * numbers, a matrix, is left committed alone.
+     */
+    private setOwned;
+    /** The size a view is laid out at, where it has been. */
+    private boxSize;
+    /** Forget the props native set on a node's view, which is gone or made again. */
+    private disown;
     /** Take an animation back from native, which stops it there. The caller plays it on, or not. */
     private stopNative;
     /**
@@ -1339,6 +1432,13 @@ export declare class Engine implements HostEngine {
     private reportHeld;
     private reportMissingKeyframes;
     private transitioned;
+    /**
+     * What a view was last painted with, by property, for a transition that arrives with the change
+     * it eases: CSS takes the transition from the style after the change and eases from the value
+     * before it. Nothing for a view nobody has seen yet, which starts where it is. The individual
+     * transforms are read back from the parts the painted transform was put together from.
+     */
+    private paintedBefore;
     /** Nobody saw what the last commit gave a view it created, so this is where the view starts. */
     private unseenTransitions;
     /** The elements native is playing a transition of. */
@@ -1367,6 +1467,17 @@ export declare class Engine implements HostEngine {
      * A width eased from JavaScript is a commit a frame, and a commit lays the whole screen out.
      */
     private layEased;
+    /** When each size in transition was last started, and how many starts in a row came soon. */
+    private readonly laidStarts;
+    /**
+     * Whether a transition of a size is one sent on again and again, each before the last had
+     * ended: a progress bar that steps every 50ms and eases each step over 150. Native moves the
+     * view, and lays the screen out, every frame while a layout animation runs, so one started at
+     * every step is one that never stops. The first, and one sent back before it ends, are
+     * played; from the second sent on in a row, each is committed where it ends, and the steps
+     * are the motion. Played again once the size has been left alone for as long as it lasts.
+     */
+    private sentOnAgain;
     /** The animations this commit lays out at their last frame, for native to move the views to. */
     private laidPlayed;
     /**
@@ -1427,6 +1538,8 @@ export declare class Engine implements HostEngine {
      * `lettingGo`.
      */
     private keeps;
+    /** Whether a node, or an element it is in, is `display: none`. */
+    private boxless;
     /** One `@keyframes` player, one frame on. */
     private advancePlayer;
     /**
@@ -1563,6 +1676,11 @@ export declare class Engine implements HostEngine {
      * keeps for hoisted nodes that are gone.
      */
     private reconcileHoistTarget;
+    /**
+     * `reconcileHoistTarget` for a node that commits only what is hoisted into it
+     * (`HoistOptions.only`): those nodes, in the order they were written, and none of its own.
+     */
+    private reconcileOnlyHoisted;
     /**
      * A child's handle as a child of `parent`, created again when it was committed under another.
      *
@@ -1596,6 +1714,17 @@ export declare class Engine implements HostEngine {
      * itself so the native side sees an update rather than a removal.
      */
     private standIn;
+    /**
+     * What a hoist target takes of a child written in it: the child's handle, `direct` for one
+     * hoisted into it, which goes after its siblings, or null for none.
+     */
+    private takenByTarget;
+    /**
+     * A clean element's handle under `parent`, before anything else is asked of it: one committed
+     * there and unchanged since was displayed and in its place, and is still. The siblings of what
+     * changed are most of what a commit steps over: a list one row of which ticks.
+     */
+    private cleanUnder;
     /** A clean child's committed handle, when its style still holds under its parent's. */
     private stillCommitted;
     /**
@@ -1622,6 +1751,12 @@ export declare class Engine implements HostEngine {
     private readonly undefinedTokens;
     /** Said once per name: a phone has no inspector to show the declaration struck out. */
     private reportUndefinedToken;
+    private readonly droppedDeclarations;
+    /**
+     * A declaration in a style, written or bound, that is no value its property takes, so it is
+     * dropped as a browser drops it. Said once per element name and declaration, in development.
+     */
+    reportDroppedDeclaration(prop: string, value: string, on: string, why: string): void;
     private readonly unreadDisplays;
     /**
      * Said once per token and value: the compiler refuses `display: grid` written out, but a token