@ng-native/fabric 0.7.0 → 0.9.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;
@@ -194,6 +206,8 @@ export interface EngineNode extends HostNode {
     styleCache: StyleCache | null;
     /** Set when something that could change what this node matches has changed. */
     styleDirty: boolean;
+    /** See `StyleTarget.ownDirty`. */
+    ownDirty: boolean;
     /** See `StyleTarget.hasDirty`. */
     hasDirty: boolean;
     /** See `StyleTarget.stateDirty`. */
@@ -765,16 +779,21 @@ export declare class Engine implements HostEngine {
      * Mark a node whose classes changed, by what the rules that name those classes can restyle.
      *
      * A class no selector names changes no style: a library's own marker, of an overlay that is
-     * animating or a control that was touched. One named only as what a rule's element is
-     * inside, `.animating .close`, restyles the elements under the node that such rules are for.
-     * Either way a whole subtree is not styled again for a class that has no say in it. Any other
-     * class restyles the node and everything under it, as any other change to it does.
+     * animating or a control that was touched. One a rule is for the element of, `.on`, has that
+     * element matched again, and one named as what a rule's element is inside, `.animating .close`
+     * or `.close:is(.animating *)`, the elements under the node that such rules are for. What is
+     * under any of those is styled again from the rules it matched, for what it inherits: a `dark`
+     * class on the root finds no rule again for an element no `dark` rule is for. Any other class
+     * has the node and everything under it matched again, as any other change to it does.
      *
      * A sheet that names a class later restyles what it is for as it arrives, and a node not yet
      * committed is styled when it is, with the class as it is then.
      */
     private markClasses;
-    /** Have styled again each element under a node that one of `subjects`' rules could be for. */
+    /**
+     * 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.
+     */
     private markUnder;
     /**
      * The sheet of the component `node` hosts, whose `:host` rules it matches. Set again when a hot
@@ -788,13 +807,23 @@ export declare class Engine implements HostEngine {
      * the web's mount point has, unless the app's `:host` sizes it otherwise.
      */
     setDefaultStyle(node: EngineNode, style: Readonly<Record<string, unknown>> | undefined): void;
-    /** `class="a b"` from a template. Replaces the set rather than adding to it. */
+    /**
+     * `class="a b"` from a template. Replaces the set rather than adding to it. The same classes in
+     * another order are a change too, to a selector that reads the class attribute, `[class^="a"]`.
+     */
     setClasses(node: EngineNode, value: string): void;
     /** Angular's `@if`/`@for`/`ViewContainerRef` markers. Ordered, never committed. */
     createAnchor(): EngineNode;
     createText(value: string): EngineNode;
     appendChild(parent: EngineNode, child: EngineNode): void;
     insertBefore(parent: EngineNode, child: EngineNode, ref: EngineNode | null): void;
+    /**
+     * A node coming under a parent other than the one it is under, or under any once it has been
+     * taken out: what is over it may be other than it was styled under. The resolver sees that for
+     * itself by the parent's cache, except between two boxes that share one, where it is told here.
+     * Moved within its own parent, a row of a list reordered, it is styled as it was.
+     */
+    private markAdopted;
     removeChild(parent: EngineNode | null, child: EngineNode): void;
     /**
      * A child came or went under a view that takes its text as a prop: that prop changed. A span
@@ -1110,6 +1139,24 @@ export declare class Engine implements HostEngine {
      * own frames, which is what lets an element animate in without differing from anything.
      */
     private animated;
+    /**
+     * The keyframes a node's animation names: those of its own component's sheet where it has
+     * some by that name, as Angular scopes a component's keyframes in a browser, and otherwise
+     * whichever sheet has them, since any other is global.
+     *
+     * ponytail: a host is asked of the sheet it is written in before its own component's, so
+     * a `:host` animation is played by its parent's frames where both have the name.
+     */
+    private keyframesOf;
+    /** Each node's frames as they settle on it, kept for as long as they settle the same. */
+    private readonly settledFrames;
+    /**
+     * An animation's frames for the node playing it: those with a value that waits for the node,
+     * a `var()` it sets, settled against it. The same frames are answered while they settle the
+     * same, and others once a variable changes, which is what an animation under way is played
+     * on from: see `reframe`.
+     */
+    private framesFor;
     /**
      * A clock animation the scroll plays instead: the same animation where only the timeline moved,
      * and one cancelled where the name changed.
@@ -1120,7 +1167,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;
@@ -1167,6 +1214,8 @@ export declare class Engine implements HostEngine {
     private backToScript;
     /** Start the clock on an animation, unless the node is already playing this one. */
     private startPlaying;
+    /** Play an animation that has just started: by native's layout, by native's driver, or here. */
+    private playSomewhere;
     /**
      * The colour `node` inherits, for frames that set `color: currentColor`, which is that colour
      * wherever the animation has got to, as in CSS. Undefined for frames that do not.
@@ -1218,6 +1267,87 @@ 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;
+    /** The animations this commit lays out at their last frame, for native to move the views to. */
+    private laidPlayed;
+    /**
+     * Whether an animation that has just started is one native can play by laying the view out
+     * at its last frame: two frames of sizes or places, played once from where the view is drawn
+     * now, which is where native moves it from. It is then committed at that frame; see `layOut`.
+     */
+    private layPlayed;
+    /** Go on from JavaScript with an animation native was to lay out, by the clock it started on. */
+    private playLaidHere;
+    /** An animation native laid out has had its time: it is at its last frame, and says so. */
+    private endLaidPlayed;
+    /**
+     * Before a commit is handed over: ask native to move what it lays out, and take back to
+     * ease from JavaScript whatever it cannot: all of it where the commit moves anything else,
+     * and otherwise what would not take as long as the longest. Answers whether the tree has to
+     * be reconciled again.
+     */
+    private layOut;
+    /** Ask native to move what the commit lays out over `duration`, and end each when it is up. */
+    private askLayout;
+    /**
+     * 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