@ng-native/fabric 0.8.0 → 0.10.0

package/dist/css.d.ts

@@ -30,7 +30,7 @@ export interface Compound {
     readonly not?: readonly Compound[];
     /** `:host`: the node must be the host of the component whose sheet is being evaluated. */
     readonly host?: true;
-    /** `:host-context()`: the host, or one of its ancestors, must match one of these. */
+    /** `:host-context()`, once for each written: the host, or one of its ancestors, must match it. */
     readonly hostContext?: readonly Compound[];
     /**
      * `:is(<compound> *)`: every one of these must match some ancestor, the node itself excluded.
@@ -51,6 +51,11 @@ export interface Compound {
     readonly nth?: readonly NthTest[];
     /** `:empty`: no children at all, text included. */
     readonly empty?: true;
+    /**
+     * What a `::ng-deep` is written after: an element of the component the sheet is of, or its
+     * host. A rule with one is for what is under it, in other components' views too.
+     */
+    readonly own?: true;
     /** `:has()`: every one of these must find a match beneath the node. */
     readonly has?: readonly HasTest[];
 }
@@ -65,6 +70,8 @@ export interface NthTest {
     readonly a: number;
     readonly b: number;
     readonly fromEnd?: true;
+    /** Counted among the siblings with the node's own element name: `:nth-of-type()`. */
+    readonly ofType?: true;
 }
 export type Combinator = 'descendant' | 'child' | 'next-sibling' | 'later-sibling';
 export interface StyleRule {
@@ -72,6 +79,8 @@ export interface StyleRule {
     /** Between compounds; length is `compounds.length - 1`. */
     readonly combinators: readonly Combinator[];
     readonly specificity: number;
+    /** Written with `::ng-deep`: for what is under its component, in other components' views too. */
+    readonly deep?: true;
     /**
      * The cascade layer the rule is in, as its place in its sheet's `layers`, or nothing for a rule
      * in no layer, which beats every layered one whatever their specificity.
@@ -162,6 +171,16 @@ export interface TokenValue {
     readonly lineHeight?: {
         readonly __defer: DeferredDeclaration['compute'];
     };
+    /**
+     * Two to four lengths, which a shorthand of sides or corners takes a value each from:
+     * `padding: var(--list-padding)` of `--list-padding: 0.25rem 0.5rem`.
+     */
+    readonly lengths?: readonly (number | string)[];
+    /**
+     * The same where a part is a `var()`, each such part as the alias a token that is one is:
+     * `0 var(--modal-padding) var(--modal-padding)`. Worked out into `lengths` where it is defined.
+     */
+    readonly deferredLengths?: readonly (number | string | TokenValue)[];
     /** A whole shadow list, in the processed shape `boxShadow` takes. */
     readonly shadow?: readonly unknown[];
     /** One filter function, as the one-entry list `filter` takes: a slot of Tailwind's filters. */
@@ -485,6 +504,18 @@ export interface StyleCache {
     context: object;
     /** The parent's `context` this was computed from. */
     parentContext: object;
+    /**
+     * Identity token standing for what an element under this node could match differently: minted
+     * when the node is styled for a change that can alter that, and kept when it is styled again
+     * for one that cannot, a custom property of its own or an inherited value from above. An
+     * element whose parent's is the one it was last styled under matches the rules it did, so it
+     * is styled from those it kept and they are not found again.
+     */
+    scope: object;
+    /** The parent's `scope` this was computed from. */
+    parentScope: object;
+    /** The rules the node matched, for a styling that finds its parent's `scope` as it was. */
+    rules?: readonly StyleRule[];
     /** The conditions version this was resolved under. */
     generation: number;
     style: Record<string, unknown>;
@@ -570,6 +601,12 @@ export interface StyleTarget {
     styleCache: StyleCache | null;
     /** Set when something that could change what this node matches has changed. */
     styleDirty: boolean;
+    /**
+     * Set when what this node matches, or a custom property it holds, may have changed, and nothing
+     * that an element under it is matched by: the node is matched and styled again, and those under
+     * it are styled from the rules they matched. Absent on a hand-built target.
+     */
+    ownDirty?: boolean;
     /**
      * Set when something beneath this node changed and a sheet uses `:has()`: the node is matched
      * again, and restyled only if the rules it matches came out different. Absent on a hand-built
@@ -656,6 +693,15 @@ export interface SiblingReach {
  * Where no sheet reaches either way, only the elements at the two ends can match differently.
  */
 export declare function siblingReach(sheet: StyleSheet): SiblingReach;
+/**
+ * A compound whose element's place is read from another element, with the classes the rule asks
+ * of what that element is in: its parent's where `child`, and otherwise of anything above it.
+ */
+export interface PlaceReader {
+    readonly compound: Compound;
+    readonly above?: readonly string[];
+    readonly child?: boolean;
+}
 /**
  * Each compound in a sheet whose element's place among its siblings is read from another
  * element: one with something under it in the rule, `.row:nth-child(odd) .label` and
@@ -669,7 +715,7 @@ export declare function siblingReach(sheet: StyleSheet): SiblingReach;
  * A place read by the element a rule styles, or by the elements before it that the rule steps
  * from (`.a:first-child + .b`), is that element's own: the rules it matches say.
  */
-export declare function placeReadElsewhere(sheet: StyleSheet): readonly Compound[];
+export declare function placeReadElsewhere(sheet: StyleSheet): readonly PlaceReader[];
 /** One rule in a cascade: the sheet it came from, which `:host` needs, and its weight here. */
 interface RuleEntry {
     readonly rule: StyleRule;
@@ -733,7 +779,23 @@ export interface Subjects {
     readonly inside: Set<string>;
     /** A rule for anything anywhere: no class, no name, and no such box to be in. */
     any: boolean;
+    /**
+     * In what a class reaches: a rule is for the element that has the class, `.on`, which is then
+     * matched again itself. Unset where the rules are only for elements under it.
+     */
+    own?: boolean;
 }
+/**
+ * A box a rule asks `:has()` of that is not the node it styles, `.card:has(.x) .title`, by the
+ * classes the rule asks of that box, with what the rule is for: the nodes under such a box to
+ * match again when what is in it changes.
+ */
+export interface HasAbove {
+    readonly classes: readonly string[];
+    readonly subjects: Subjects;
+}
+/** Each box a sheet's rules ask `:has()` of above the node they style. */
+export declare function hasAbove(sheet: StyleSheet): readonly HasAbove[];
 /** Whether an inline style sets a property children inherit. Allocates nothing: it runs per set. */
 export declare function setsInherited(style: unknown): boolean;
 /**
@@ -855,6 +917,12 @@ export declare class StyleResolver {
     /** The tests of the `class` attribute itself in those sheets, which any class may answer. */
     private readonly classTests;
     private readonly noted;
+    /**
+     * The sheets with a rule written with `::ng-deep`, which is for what is under the component
+     * in the views of the components it holds. None in most apps, and nothing is asked then.
+     */
+    private readonly deepSheets;
+    private readonly deepIndexes;
     /** Read the classes a sheet names, once, as soon as any node is given it. */
     noteSheet(sheet: StyleSheet | null | undefined): void;
     /** The props a selector of some sheet asks about: an id, and each attribute by its name. */
@@ -865,10 +933,13 @@ export declare class StyleResolver {
      */
     reads(prop: string): boolean;
     private noteReach;
+    /** Whether a class's reach names any element under the one that has it. */
+    reachesUnder(subjects: Subjects): boolean;
     /**
      * What classes coming to an element or going from it can restyle: `true` for it and all
-     * under it and after it, as any change to it does; the elements under it to restyle, by what
-     * rules are for; or null, where no rule names any of them and nothing is styled again.
+     * under it and after it, as any change to it does; the element itself, where `own`, and the
+     * elements under it to match again, by what rules are for; or null, where no rule names any
+     * of them and nothing is styled again.
      */
     reachOf(classes: Iterable<string>): true | Subjects | null;
     /** Whether one of the rules `subjects` stands for could be for a node. */
@@ -889,6 +960,15 @@ export declare class StyleResolver {
      * resolves at most once however many descendants ask for its inherited values.
      */
     resolve(node: StyleTarget, epoch: number): StyleCache;
+    /** A node styled now, from the rules found for it or from those it kept: see `matchesStand`. */
+    private styledAgain;
+    /**
+     * Whether what an element could match is as it was when it was last styled: nothing that can
+     * change it was marked on the element, its parent's `scope` is the one it was styled under,
+     * and no sheet that could match it has come since. It is being styled again all the same, for
+     * a change of its own that alters nothing under it, or for what it inherits.
+     */
+    private matchesStand;
     /**
      * A cache of a node just styled, with a context of its own. It keeps the rules the node
      * matched, for the node to be compared with, once a sheet has a use for them: see `tracksHas`.
@@ -925,6 +1005,12 @@ export declare class StyleResolver {
      * without resolving it. What lets a commit step over a clean child in one comparison.
      */
     holds(node: StyleTarget, parentContext: object): boolean;
+    /**
+     * Whether a node was last styled under a box holding the one cache shared by every box with
+     * nothing to style. Such boxes hand the same `context` down, so the node cannot tell one from
+     * another by it: moved under another box, it has to be told.
+     */
+    styledUnderShared(node: StyleTarget): boolean;
     /**
      * Whether a previous result still stands: nothing about the node changed, nothing above it
      * moved, and the conditions have not.
@@ -945,6 +1031,8 @@ export declare class StyleResolver {
      * token the device had seeded.
      */
     private unstyled;
+    /** The one cache of every node with nothing to style and nothing to hand down, given to one more. */
+    private sharedEmpty;
     /**
      * The rules worth trying against a node, in cascade order.
      *
@@ -966,6 +1054,13 @@ export declare class StyleResolver {
      * it, so it loses to their extra attribute and wins a tie with them.
      */
     private rulesFor;
+    /**
+     * Add the `::ng-deep` rules of each component a node is in whose sheet is not the node's own:
+     * a node is tried against its own component's rules already, those among them.
+     */
+    private reachedFromAbove;
+    /** A sheet's `::ng-deep` rules alone, filed as a component's own are. */
+    private deepIndex;
     /** Weakest first: by layer where any sheet has one, then by weight, then as they were filed. */
     private readonly cascadeOrder;
     /** A component's sheet as the rules of a host or of a creator, which differ only in their place. */
@@ -1006,6 +1101,8 @@ export declare class StyleResolver {
      * edge the inline style sets takes the other form of it out, as a later rule would.
      */
     overOtherForms(inline: Readonly<Record<string, unknown>>, style: Record<string, unknown>): void;
+    /** Whether a settled style is of an element read right to left: by its own, or the app's. */
+    readsRightToLeft(style: Readonly<Record<string, unknown>>): boolean;
     /**
      * The direction an element is laid out in: the last `direction` its own rules give it, the one
      * it inherits, or the app's. A logical corner is a different physical one in each.
@@ -1030,6 +1127,11 @@ export declare class StyleResolver {
      * A declaration with no token and no usable fallback is dropped rather than written as
      * undefined, which is what a browser does with a value it cannot resolve.
      */
+    /**
+     * What declarations that wait for a node's tokens come to on it, where no rule of the node's
+     * carries them: a keyframe's, which is settled against the element that plays it.
+     */
+    settleFor(node: StyleTarget, deferred: readonly DeferredDeclaration[], epoch: number): Record<string, unknown>;
     private applyDeferred;
     /** Note what the node being resolved takes an `inherit` from, and that its parent has an heir. */
     private heir;