@ng-native/fabric 0.4.0 → 0.5.0

package/dist/engine.d.ts

@@ -194,6 +194,10 @@ export interface EngineNode extends HostNode {
     styleCache: StyleCache | null;
     /** Set when something that could change what this node matches has changed. */
     styleDirty: boolean;
+    /** See `StyleTarget.hasDirty`. */
+    hasDirty: boolean;
+    /** See `StyleTarget.stateDirty`. */
+    stateDirty: boolean;
     /** A family left out while it loads. See `loadingFamilies`. */
     heldFamily?: string;
     /** See `StyleTarget.inlineInherits`. */
@@ -230,6 +234,18 @@ export interface EngineNode extends HostNode {
     ownStyle?: object;
     /** The resolved style this node was last committed with, for the skip check in `reconcile`. */
     styleCommitted: StyleCache | null;
+    /**
+     * How this node laid its children out when one of them last had a `fit-content` size, as
+     * `containerOf` says it. Set by such a child, and compared on each reconcile so the children
+     * are worked out again when the direction or alignment changes. Unset on every other node.
+     */
+    fitContainer?: string;
+    /**
+     * Whether this node had a height a percentage could be taken of, when a box beneath it with a
+     * percentage height last asked, as `definiteHeight` says it. Compared on each reconcile so its
+     * children are worked out again when it changes. Unset on every other node.
+     */
+    heightBasis?: boolean;
     /**
      * Per-property transition state, for every property this node has ever seen a `transition` for.
      * A finished entry stays, because its target is what the next change is measured against.
@@ -267,6 +283,10 @@ export interface EngineNode extends HostNode {
     componentHost?: true;
     /** See `keepNativeView`. */
     nativeView?: true;
+    /** Props kept for selectors to match and left out of what is committed. See `keepAsAttribute`. */
+    attributeOnly?: Set<string>;
+    /** The child this node's background is painted on instead of itself. See `paintOn`. */
+    paintsOn?: EngineNode;
     /**
      * Style weaker than every sheet, where no rule and no inline style says otherwise. What lets the
      * root component's host fill the surface by default and still give way to its own `:host`. See
@@ -426,6 +446,8 @@ export interface ViewNameNode {
     readonly nativeView?: boolean;
     /** What it holds, which decides whether one of HTML's text elements is text or a view. */
     readonly children?: readonly ViewNameNode[];
+    /** Set on the paragraph the engine makes for a run of text written straight into a view. */
+    readonly anonymous?: boolean;
 }
 /**
  * The native view a node commits as: `Paragraph` for a `<text>`, `VirtualText` for one nested in
@@ -567,6 +589,8 @@ export declare class Engine implements HostEngine {
      * does, a child list can move without anything else needing to be looked at again.
      */
     private structuralSheets;
+    /** Whether any sheet uses `:has()`. See `markBeneath`. */
+    private hasSheets;
     private readonly resolveAssetSource;
     constructor(fabric: FabricUIManager, rootTag: number, options?: EngineOptions);
     /**
@@ -590,6 +614,25 @@ export declare class Engine implements HostEngine {
      * binding, so nothing marks an Angular view dirty and no change-detection pass would follow.
      */
     private setActiveChain;
+    /** 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. */
+    private readonly activeBySheet;
+    /** Note what a sheet in play asks about a pressed element. See `markActive`. */
+    private watchActive;
+    /** A sheet has left play, by a hot swap or by being removed: what it asked goes with it. */
+    private unwatchActive;
+    private countActive;
+    /**
+     * A press began or ended on `node` or under it, which is all that changed about it. A press
+     * reaches every ancestor up to the root, and marking each as restyled would style the whole
+     * screen again, twice a press. So each is only matched again, and keeps its style and all
+     * that is under it unless it now matches other rules. An element a rule asks about from
+     * inside or beside it, `.card:active .title`, changes more than itself, and is restyled with
+     * everything under it as any other change is. With no rule for a pressed element at all there
+     * is nothing to match.
+     */
+    private markActive;
     /**
      * Custom properties the device knows and the stylesheet cannot, once they change.
      *
@@ -765,6 +808,20 @@ export declare class Engine implements HostEngine {
     parentNode(node: EngineNode): EngineNode | null;
     nextSibling(node: EngineNode): EngineNode | null;
     setProp(node: EngineNode, key: string, value: unknown): void;
+    /**
+     * Paint a node's background on one of its children instead of on the node: the node keeps its
+     * `background-color` and `background-image` in the cascade, where a stylesheet wrote them, and
+     * the child is the view that draws them. What a view that masks its children and not itself
+     * needs, as `<gradient-text>` is.
+     */
+    paintOn(node: EngineNode, child: EngineNode): void;
+    /**
+     * Keep a prop the node already has as an attribute: on the node for a selector such as
+     * `:host([variant='primary'])` to match, and left out of what is committed to the native view.
+     * It is committed again once the prop is next written. What the platform adapter does with a
+     * static attribute that is an input of the host's component.
+     */
+    keepAsAttribute(node: EngineNode, key: string): void;
     /**
      * Whether a node's inline style can change what it or anything below it resolves to: it sets,
      * or until now set, a property its children inherit.
@@ -798,6 +855,14 @@ export declare class Engine implements HostEngine {
     setText(node: EngineNode, value: string): void;
     setEventListener(node: EngineNode, topLevelType: string, fn: (event: unknown) => void): () => void;
     private markProps;
+    /** Start matching ancestors again on a change, once a sheet that uses `:has()` is in play. */
+    private watchHas;
+    /**
+     * Something at or beneath `from` changed: every node from there up may match a `:has()` rule
+     * it did not, or stop matching one. They are matched again rather than marked for restyling,
+     * which would restyle everything under them. Only sheets that use `:has()` pay.
+     */
+    private markBeneath;
     private markLaterSiblings;
     /** `node`'s child list changed: `moved` came into it or went out of it. */
     private markStructure;
@@ -877,6 +942,20 @@ export declare class Engine implements HostEngine {
      * unrelated change.
      */
     private mergeProps;
+    /**
+     * Leave a node's background out of what it commits when a child paints it, and give that child
+     * its parent's: the cascade's, and over it the parent's inline style.
+     */
+    private movePaint;
+    /**
+     * A container whose direction or alignment changed since a child with a `fit-content` size
+     * read it, or whose height stopped or started being one a percentage is taken of since a child
+     * with a percentage height asked: those children are merged again. A change to a container
+     * marks nothing beneath it, since none of these is inherited.
+     */
+    private refitChildren;
+    /** Have a container's children merged again, through any `display: contents` among them. */
+    private refit;
     /**
      * The text size cap that lays a paragraph or text input out again once a face it names has
      * registered: a step per face above the app's own cap where it set one (below 1 is none, on
@@ -956,6 +1035,30 @@ 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. */
+    private releasePlayedNatively;
+    /** Every node whose animation native is playing, with no frame of it in JavaScript. */
+    private readonly playedNatively;
+    /**
+     * Hand an animation that has just started to native, where native can play it: one that moves
+     * only opacity and transforms, starts at once, and repeats a whole number of times. Native then
+     * runs it frame by frame, and JavaScript hears of it again when it ends. Anything else is
+     * played from here, a commit a frame. See `NativeScrollDriver.play`.
+     */
+    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.
+     */
+    private endedNatively;
+    /** Take an animation back from native, which stops it there. The caller plays it on, or not. */
+    private stopNative;
+    /**
+     * Play on from JavaScript an animation native was playing, from where its clock has got to:
+     * what a pause, other frames or a view made again need, none of which native can be told of.
+     */
+    private backToScript;
     /** Start the clock on an animation, unless the node is already playing this one. */
     private startPlaying;
     /**
@@ -1047,7 +1150,8 @@ export declare class Engine implements HostEngine {
      *
      * A stop's colour is a colour like any other, but it is two levels down and nothing else looks
      * there: without this the device is handed the string `rgb(255, 0, 0)` where it wants a number,
-     * and paints nothing.
+     * and paints nothing. The stops are first rewritten so native's interpolation paints what
+     * CSS's premultiplied one does (see `premultipliedStops`).
      */
     private processGradients;
     private clearFlags;