@ng-native/fabric 0.7.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;
@@ -1120,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;
@@ -1218,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