@ng-native/fabric 0.16.0 → 0.17.1

package/dist/css.d.ts

@@ -26,8 +26,19 @@ export interface Compound {
     readonly attributes?: readonly AttributeTest[];
     /** `:is()` / `:where()` arguments: the compound matches if any of these do. */
     readonly is?: readonly (readonly Compound[])[];
+    /**
+     * `:is()` / `:where()` with an argument of more than a compound, `:is(.a + .b)`, once for each
+     * written: the node is the last element of one of these. Read only where `is` is set, which
+     * the compiler sets beside it, so a compound with no `:is()` pays nothing for it.
+     */
+    readonly isComplex?: readonly (readonly ComplexSelector[])[];
     /** `:not()` arguments: the compound matches only if none of these do. */
     readonly not?: readonly Compound[];
+    /**
+     * `:not()` with an argument of more than a compound: the node is the last of none of these.
+     * Read only where `not` is set, as `isComplex` is.
+     */
+    readonly notComplex?: readonly ComplexSelector[];
     /** `:host`: the node must be the host of the component whose sheet is being evaluated. */
     readonly host?: true;
     /** `:host-context()`, once for each written: the host, or one of its ancestors, must match it. */
@@ -64,6 +75,25 @@ export interface HasTest {
     /** `:has(> x)`: a child, not any descendant. */
     readonly child?: true;
     readonly any: readonly Compound[];
+    /**
+     * Arguments that are more than one compound for a descendant or a child, `:has(+ .a)` or
+     * `:has(.a > .b)`: some element related to the node by one of these is its last.
+     */
+    readonly relative?: readonly RelativeSelector[];
+}
+/** Compounds joined by combinators, matched leftwards from the last as a rule's are. */
+export interface ComplexSelector {
+    readonly compounds: readonly Compound[];
+    /** Between compounds; length is `compounds.length - 1`. */
+    readonly combinators: readonly Combinator[];
+}
+/**
+ * A `:has()` argument, which starts at the node it is asked of: `combinators[0]` joins that node
+ * to `compounds[0]`, and each one after joins the compound before it to the next.
+ */
+export interface RelativeSelector {
+    readonly compounds: readonly Compound[];
+    readonly combinators: readonly Combinator[];
 }
 /** `an + b`, counted from the start unless `fromEnd`. */
 export interface NthTest {
@@ -141,6 +171,11 @@ export interface Conditions {
      * (`Engine.remeasureText`), which `watchConditions` does after it.
      */
     readonly fontScale?: number;
+    /**
+     * The screen's pixels in a point: `PixelRatio.get()`. Nothing in the engine reads it; a
+     * package answering a page's `devicePixelRatio` does. Optional, and 1 when absent.
+     */
+    readonly pixelRatio?: number;
     /**
      * The direction the app is laid out in, which is the device's unless the app forced one:
      * `I18nManager.isRTL`. Optional, and left to right when absent. It decides which physical
@@ -302,6 +337,11 @@ export interface DeferredDeclaration {
         readonly scale?: number;
         readonly offset?: number;
         readonly floor?: number;
+        /**
+         * A percentage the length is added to, `calc(100% - var(--x))`: written as that sum, which
+         * the engine works out once the box the percentage is of has been laid out.
+         */
+        readonly percent?: number;
         /**
          * The reference is multiplied by a length, so it is a number: `calc(var(--n) * 1px)`. Without
          * this it is a length, and a number token is no such thing, as CSS types a calc().
@@ -469,6 +509,11 @@ export interface StyleSheet {
      * has to re-resolve a whole child list when it changes. It only does that where a sheet asks.
      */
     readonly structural?: true;
+    /**
+     * Some rule is for a generated box, `::before` or `::after`, which only a sheet compiled to
+     * draw them has. Said on the sheet so the engine reads the rules of no other for one.
+     */
+    readonly generated?: true;
     /**
      * Some rule uses `:has()`, so what a node matches can change when something beneath it does.
      * Said on the sheet for the same reason `structural` is: the cost is invalidation, and only a
@@ -549,27 +594,34 @@ export interface StyleCache {
 }
 /**
  * Whether a child is one `:empty` sees. An anchor is a comment on the web, which it does not;
- * nor text of no length, which a binding to nothing leaves behind.
+ * nor text of no length, which a binding to nothing leaves behind; nor a box a rule generated,
+ * which is not in the tree a selector is matched against.
  */
 export declare function fills(child: StyleTarget): boolean;
 /** What the matcher needs of a node. The engine's node satisfies this structurally. */
 export interface StyleTarget {
     readonly tag: string;
+    /** The name a type selector reads, where it is not `tag`: see `EngineNode.typeName`. */
+    readonly typeName?: string;
+    /** Set on a node of a library's drawing: see `EngineNode.namespace`. */
+    readonly namespace?: string;
     readonly parent: StyleTarget | null;
     /**
      * Needed only by the selectors that ask about a node's place among its siblings, which is why
      * it is read through the parent rather than kept as an index: an index would have to be right
      * after every insertion and removal, and this is right by construction.
      */
-    readonly children?: readonly StyleTarget[];
+    readonly childList?: readonly StyleTarget[];
     /**
      * Only elements are counted by the selectors that ask about position. Text is not one, and
      * neither is the anchor a structural directive leaves behind - the same reason a browser does
      * not count a comment. Absent means element, so a hand-built target needs nothing extra.
      */
-    readonly kind?: string;
+    readonly nodeKind?: string;
     readonly classes: ReadonlySet<string> | null;
     readonly props: Readonly<Record<string, unknown>>;
+    /** Attributes a package keeps apart from props, for selectors alone: see `attributeOf`. */
+    readonly keptAttributes?: Readonly<Record<string, string>>;
     /**
      * Whether `props.style` sets a property children inherit, kept by whoever sets the style so the
      * resolver reads the style only where it can matter. Absent is false.
@@ -589,9 +641,9 @@ export interface StyleTarget {
      * created it. Read from the node rather than passed in, because a node's ancestors usually
      * belong to other components and must be matched against their own sheets, not this one's.
      */
-    readonly sheet: StyleSheet | null;
+    readonly templateSheet: StyleSheet | null;
     /**
-     * The sheet of the component this node is the *host* of, if it is one. Distinct from `sheet`,
+     * The sheet of the component this node is the *host* of, if it is one. Distinct from `templateSheet`,
      * which is the sheet of the component that *created* it: a host node is created by the parent,
      * so those two are always different sheets and `:host` needs the second.
      */
@@ -636,6 +688,8 @@ export interface StyleTarget {
      */
     active?: boolean;
 }
+/** Whether a prop of a shape in a drawing is a paint it hands down: see `inheritFrom`. */
+export declare const handsDownPaint: (key: string) => boolean;
 /**
  * Deterministic work counters for the matcher.
  *
@@ -669,13 +723,31 @@ export declare const styleStats: {
     rulesFiled: number;
     /** Nodes asked whether a rule `:has()` was asked for could be for them: see `isFor`. */
     subjectTests: number;
+    /** Children whose place in a list `:has()` noted, to step from one to the next. */
+    placesIndexed: number;
 };
 export declare function resetStyleStats(): void;
+/**
+ * A node's attribute as a selector reads it: the one a package keeps for it apart from its props,
+ * where it keeps one by that name, and otherwise its prop. See `Engine.keepAttribute`.
+ */
+export declare const attributeOf: (node: StyleTarget, name: string) => unknown;
+/** Note that a sheet in play draws generated boxes: see `boxesDrawn`. */
+export declare function noteGeneratedBoxes(): void;
+/** Keep `:has()` answers from here, or stop keeping them. */
+export declare function keepHasAnswers(keep: boolean): void;
+/** Drop the `:has()` answers kept, for something beneath a node changed. */
+export declare function forgetHasAnswers(): void;
 /**
  * Right-to-left matching, as every CSS engine does it: the rightmost compound is the cheapest
  * filter and rejects almost everything immediately.
  */
 export declare function matches(node: StyleTarget, rule: StyleRule, sheet?: StyleSheet | null): boolean;
+/**
+ * Whether an element's name is a generated box's, `::before` or `::after`: a child the engine
+ * keeps for a rule that draws one, which no selector counts among the element's children.
+ */
+export declare const isGenerated: (name: string) => boolean;
 /** A node's first `count` elements, or its last, skipping everything that is not one. */
 export declare function elementsAtEnd<T extends StyleTarget>(siblings: readonly T[], count: number, fromEnd: boolean): T[];
 /**
@@ -728,6 +800,18 @@ export declare function placeReadElsewhere(sheet: StyleSheet): readonly PlaceRea
  * those whose change can restyle the elements after it. An id is asked as `nativeID`.
  */
 export declare function namedBeside(sheet: StyleSheet): ReadonlySet<string>;
+/**
+ * Gives each prop in `style` that a shorthand the element sets itself covers the shorthand's
+ * value: one in its inline style, `inline`, or bound from a token, `bound`. The value rather than
+ * nothing, so a transition of the side eases to it, as in a browser. Not a prop the element sets
+ * as well, which Yoga reads over its shorthand as before, nor one a rule marked `!important`,
+ * which beats the element's own declaration. Of two shorthands over one prop, the one React Native
+ * reads: `paddingInline` over `paddingHorizontal`, whichever was written first.
+ *
+ * Per commit for every element with a style of its own, so it walks the props in `style`, a few,
+ * rather than every side and corner a shorthand covers.
+ */
+export declare function underOwnShorthands(style: Record<string, unknown>, inline: Readonly<Record<string, unknown>>, bound: ReadonlyMap<string, unknown> | undefined, important: ReadonlySet<string> | undefined): void;
 /** One rule in a cascade: the sheet it came from, which `:host` needs, and its weight here. */
 interface RuleEntry {
     readonly rule: StyleRule;
@@ -749,8 +833,11 @@ export declare function ruleKey(rule: StyleRule): string;
  * `:is()` of compounds that each have a key: it is filed under each of theirs, since a node it
  * matches has one of them.
  *
- * A rule that says nothing of the node's own name can still say whose child it is, `.row > *`.
- * It is filed under the parent's class, and offered to the children of an element that has it.
+ * Two kinds of rule say nothing of the node's own name and still say whose child it is: one for
+ * a generated box, `.card::before`, which is `.card > ::before` here, and one for any child,
+ * `.row > *`. Each is filed under the parent's class, and offered to the children of an element
+ * that has it. Filed by the box's own name, every `::before` rule there is would be offered to
+ * every such box.
  */
 export declare function ruleKeys(rule: StyleRule): readonly string[];
 /** A rule in an index, and where it comes among rules of the same weight: the order it was written in. */
@@ -814,20 +901,45 @@ export interface Subjects {
  */
 export interface HasAbove {
     readonly classes: readonly string[];
+    /** The element the box is, where the rule names one. */
+    readonly type?: string;
     readonly subjects: Subjects;
+    /**
+     * The box is before the node, or before a box the node is in: `.card:has(.x) ~ .title`. What
+     * comes after it is matched again as well as what is under it.
+     */
+    readonly beside?: true;
 }
-/** Each box a sheet's rules ask `:has()` of above the node they style. */
+/** Each box a sheet's rules ask `:has()` of other than the node they style. */
 export declare function hasAbove(sheet: StyleSheet): readonly HasAbove[];
+/** Whether `node` can be the box a `:has()` rule asks: it has the classes and is the element. */
+export declare function couldAsk(reader: HasAbove, node: StyleTarget): boolean;
+/**
+ * Whether a sheet asks `:has()` about what comes after a node, `:has(+ .x)` or `:has(~ .x .y)`:
+ * then a change can change what the elements before it match, and those before what it is in.
+ */
+export declare function hasBeside(sheet: StyleSheet): boolean;
 /** What all of `each` are for, as one. */
 export declare function joinSubjects(each: readonly Subjects[]): Subjects;
-/** Whether an inline style sets a property children inherit. Allocates nothing: it runs per set. */
-export declare function setsInherited(style: unknown): boolean;
+/**
+ * A node's `class` attribute, as `[class^="icon-"]` reads it, before a change to its classes and
+ * after: undefined where it has none.
+ */
+export interface ClassChange {
+    readonly was: string | undefined;
+    readonly now: string | undefined;
+}
+/**
+ * Whether an inline style sets a property children inherit, by a node of a library's drawing or by
+ * any other. Allocates nothing, and calls nothing a key: it runs per set.
+ */
+export declare function setsInherited(style: unknown, drawing?: boolean): boolean;
 /**
  * The inherited properties a node's inline style sets, or null for none. Inline style is the
  * strongest normal declaration on its element, so what it sets is inherited, and read by
  * `color: inherit` and `currentColor`, as a rule's would be.
  */
-export declare function inlineInherited(style: unknown): Record<string, unknown> | null;
+export declare function inlineInherited(style: unknown, drawing?: boolean): Record<string, unknown> | null;
 /**
  * The runtime half of CSS for one engine: the global sheet, the conditions media queries are
  * evaluated against, and the memo that makes resolution cost nodes x rules rather than
@@ -842,7 +954,7 @@ export declare function inlineInherited(style: unknown): Record<string, unknown>
  *
  * Correctness first. Walking up meant matching every ancestor against the *starting node's*
  * sheet, but an ancestor almost always belongs to a different component, so a component's rules
- * reached nodes it did not own while a parent's real values never arrived. Reading `sheet` off
+ * reached nodes it did not own while a parent's real values never arrived. Reading `templateSheet` off
  * each node fixes both directions at once.
  *
  * Cost second. Walking up re-derived, for every node, everything its parent had already worked
@@ -934,8 +1046,8 @@ export declare class StyleResolver {
      * them could match. Emptied by anything else that moves the generation on.
      */
     private readonly additions;
-    /** Whether a sheet could match a node: one of its rules is written for it. */
-    couldMatch(sheet: StyleSheet, node: StyleTarget): boolean;
+    /** What the rules of several sheets are for, as one: see `isFor`. */
+    subjectsOfAll(sheets: readonly StyleSheet[]): Subjects;
     /** How far each class named by the sheets met so far reaches: see `classReach`. */
     private readonly reach;
     /** The tests of the `class` attribute itself in those sheets, which any class may answer. */
@@ -947,6 +1059,8 @@ export declare class StyleResolver {
      */
     private readonly deepSheets;
     private readonly deepIndexes;
+    /** Each component sheet's rules for a box of its host: see `hostBoxIndex`. */
+    private readonly hostBoxIndexes;
     /**
      * Read the classes a sheet names, once, as soon as any node is given it. One `scoped` to a
      * component or a host asks of its elements for good, global or not.
@@ -980,9 +1094,11 @@ export declare class StyleResolver {
      * 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;
+    reachOf(classes: Iterable<string>, attribute?: ClassChange): true | Subjects | null;
     /** How far a class reaches by its name, and by each test of the class attribute it answers. */
     private reachesOf;
+    /** Whether a sheet tests the `class` attribute as a whole: see `ClassChange`. */
+    get testsClassAttribute(): boolean;
     /** Whether one of the rules `subjects` stands for could be for a node. */
     isFor(subjects: Subjects, node: StyleTarget): boolean;
     /**
@@ -1019,9 +1135,9 @@ export declare class StyleResolver {
      */
     private cached;
     /**
-     * Set by the engine once a sheet uses `:has()`, styles a pressed element or asks about a place
-     * in a child list. Until then no cache keeps the rules it matched, so an app that never asks
-     * pays nothing for it.
+     * Set by the engine while a sheet in play uses `:has()` or styles a pressed element, and once
+     * one asks about a place in a child list. Otherwise no cache keeps the rules it matched, so an
+     * app that never asks pays nothing for it.
      */
     tracksHas: boolean;
     /**
@@ -1103,6 +1219,13 @@ export declare class StyleResolver {
      * a node is tried against its own component's rules already, those among them.
      */
     private reachedFromAbove;
+    /**
+     * A sheet's rules for a box of its host alone, `:host::before` and `:host(.x)::after`, filed as
+     * a component's own are. Its other rules for a box are for the elements of its template, which
+     * is how emulated encapsulation scopes them on the web: `.icon::before` in it never reaches the
+     * box of a host its parent puts the class `icon` on.
+     */
+    private hostBoxIndex;
     /** 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. */