@ng-native/fabric 0.6.0 → 0.8.0

package/dist/engine.d.ts

@@ -25,6 +25,8 @@ interface ScrollAnimation {
         offset: number;
         value: unknown;
     }[]>;
+    /** The properties among `tracks` declared `!important`, left where the rule puts them. */
+    readonly pinned: readonly string[];
     readonly resting: Record<string, unknown>;
     readonly first: Record<string, unknown>;
     /** The colour the node inherits, which the tracks were built with, for frames that read it. */
@@ -52,6 +54,16 @@ export interface FabricUIManager {
     /** Clone with the given props and the given children (omitting them means none). */
     cloneNodeWithNewChildrenAndProps(node: FabricNode, newProps: object): FabricNode;
     appendChild(parent: FabricNode, child: FabricNode): FabricNode;
+    /**
+     * Have native move each view whose frame the next commit changes to where it ends up, over a
+     * time and by one of its own curves, with no frame of it in JavaScript.
+     */
+    configureNextLayoutAnimation?(config: {
+        duration: number;
+        update: {
+            type: string;
+        };
+    }, ended: () => void, failed: () => void): void;
     createChildSet(rootTag: number): FabricNodeSet;
     appendChildToSet(set: FabricNodeSet, child: FabricNode): void;
     completeRoot(rootTag: number, set: FabricNodeSet): void;
@@ -303,6 +315,10 @@ export interface EngineNode extends HostNode {
     committedUnder: EngineNode | null;
     /** The hoisted views this node keeps committed for, by element name. See `HoistOptions`. */
     kept?: Map<string, KeptHoist>;
+    /** On a text field, the row aligned by baseline that takes a baseline from it: `lineBaseline`. */
+    onBaseline?: EngineNode;
+    /** On such a row, the fields it has marked, which it unmarks when they are no longer its own. */
+    baselineFields?: Set<EngineNode>;
     /** Commit this node again with its children so Fabric measures it again. `remeasureText`. */
     remeasure?: true;
     /**
@@ -1116,7 +1132,7 @@ export declare class Engine implements HostEngine {
      * asks for another by name, or its keyframes went, as a browser fires it.
      */
     private cancelPlaying;
-    /** Stop on native each animation whose view has left the tree. */
+    /** Stop on native each animation and transition whose view has left the tree. */
     private releasePlayedNatively;
     /** Every node whose animation native is playing, with no frame of it in JavaScript. */
     private readonly playedNatively;
@@ -1214,6 +1230,72 @@ export declare class Engine implements HostEngine {
     private reportHeld;
     private reportMissingKeyframes;
     private transitioned;
+    /** 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. */
+    private readonly easedNatively;
+    /**
+     * Hand to native each transition that just started and that it can play: opacity and
+     * transforms, with no wait before they start. Those that start together, take as long and ease
+     * alike share a clock. Nothing of them runs in JavaScript until native says they have ended:
+     * a press that fades or slides something is a commit to start it and a commit to end it.
+     *
+     * ponytail: a colour is eased from JavaScript still, a commit a frame, and so is anything
+     * that waits. Native has a colour node for the first; give the driver a channel for it.
+     */
+    private easeNatively;
+    /** The root's children as the views they are committed as, each reconciled. */
+    private rootHandles;
+    /** The transitions this commit lays out where they end, for native to move the views to. */
+    private laying;
+    /** Whether this commit resizes or moves a box that is in no such transition. */
+    private movesOthers;
+    /**
+     * Commit where it ends each transition of a size or a place that just started, for native to
+     * move the view there: a layout animation, which the commit asks for once it is known that
+     * nothing else in it moves. One still on its way is committed where it ends too.
+     *
+     * A width eased from JavaScript is a commit a frame, and a commit lays the whole screen out.
+     */
+    private layEased;
+    /**
+     * Before a commit is handed over: ask native to move what it lays out, or take the
+     * transitions back to ease them from JavaScript where the commit moves anything else, and
+     * where they would not all take as long. Answers whether the tree has to be reconciled again.
+     */
+    private layOut;
+    /**
+     * Note a commit that resizes or moves a box in no transition native lays out: a prop of one
+     * that moves boxes, children that came or went, text longer or shorter than it was.
+     */
+    private noteMoved;
+    /** A transition native laid out has had its time: it is where it ends, and says so. */
+    private endLaid;
+    /**
+     * Bring a transition native laid out to where its clock has got to, where it is sent another
+     * way or its rule has gone: that is where it goes on from.
+     */
+    private takeBackLaid;
+    private startEased;
+    private playEased;
+    /**
+     * Native reached the end of the transitions on one clock. Where they end is committed before
+     * the view is let go, so nothing shows of where they started, which is what it was committed
+     * with.
+     */
+    private endedEased;
+    /** No longer one native is easing, once none of its transitions is native's. */
+    private forgetEased;
+    /**
+     * Take back from native each transition it can no longer play as it was started: one sent
+     * another way, one whose rule has gone, any of a view that was made again. Each is brought to
+     * where its clock has got to, which is where it goes on from, here or on native again.
+     */
+    private takeBackEased;
+    /** Stop a clock native runs, and go on from JavaScript with each transition it was playing. */
+    private backToScriptEased;
+    /** Let go of what native is easing on an element that is going, or gone. */
+    private stopEased;
     /**
      * Whether an animation that has finished goes on holding its last frame. With a forwards fill
      * it does, for good: without one the element falls back to whatever the cascade gives it, and
@@ -1254,6 +1336,27 @@ export declare class Engine implements HostEngine {
      * that colour as a number and throws on a string, taking the whole surface down with it.
      */
     private processFilters;
+    /**
+     * Mark the text field each box of a row aligned by baseline takes its baseline from, before
+     * the field is merged, and unmark it when the row is aligned another way.
+     */
+    private noteBaselineFields;
+    private onBaselineOf;
+    /**
+     * Have the text a row aligned by baseline takes a baseline from measured again, where that
+     * text is inside one of the row's boxes and the row is committed again. React Native keeps
+     * what a paragraph measured on the one copy of its node that was measured, and Yoga copies a
+     * node it lays out around: a row that is laid out again asks a box for its baseline, the box
+     * asks the paragraph in it, and a copy that was never measured works it out then, on a node
+     * that is by then not to be changed. A debug build stops there. Committed to be measured
+     * again (`remeasure`), the paragraph is measured in this commit and has the answer.
+     *
+     * ponytail: the first box in the flow at each level, which is the one Yoga asks unless
+     * another is aligned by baseline itself. A row a commit lays out again without the engine
+     * cloning it, as its room changing does, is not reached: clone on a layout event if one is
+     * seen to stop there.
+     */
+    private freshBaselines;
     /**
      * Copy a list of gradients, running every stop's colour through the host's converter.
      *