@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-tree.d.ts

@@ -0,0 +1,499 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, TemplateRef } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the tree and every row inside it sit at. */
+type TreeSize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the tree draws its own box. `framed` is the standalone control;
+ * `plain` is what a panel that already has an edge renders inside itself.
+ */
+type TreeVariant = 'plain' | 'framed';
+/** How many nodes may be chosen at once. */
+type TreeSelectionMode = 'none' | 'single' | 'multiple';
+/**
+ * Which of the two models the pattern offers is in force. `toggle` is the
+ * recommended one and holds no modifier; `replace` is the alternative.
+ */
+type TreeSelectionBehavior = 'toggle' | 'replace';
+/**
+ * How the selection is drawn, and which attribute states it. The pattern allows
+ * `aria-selected` or `aria-checked` and never both; `auto` reads the mode
+ * beside it, which is the convention the pattern's own note recommends.
+ */
+type TreeSelectionIndicator = 'auto' | 'highlight' | 'checkbox' | 'none';
+/** Whether pressing a branch takes its descendants with it. */
+type TreeSelectionCascade = 'none' | 'descendants';
+/** What a press on the row does to a branch. */
+type TreeExpandOn = 'row' | 'expander';
+/**
+ * How the keyboard's position is expressed. `auto` reads one fact — whether the
+ * set is windowed — and answers `activedescendant` when it is, because a roving
+ * tab stop cannot survive its own element being recycled.
+ */
+type TreeFocusMode = 'auto' | 'roving' | 'activedescendant';
+/**
+ * Whether the nodes are nested in `role="group"` elements or laid flat with
+ * their level stated. A window renders a slice and a slice cannot preserve
+ * nesting, so `auto` answers `flat` while windowed.
+ */
+type TreeStructure = 'auto' | 'nested' | 'flat';
+/** Where `scrollToKey` puts the node it reveals. */
+type TreeAlignment = 'start' | 'center' | 'end' | 'nearest';
+interface TreeDefaults {
+    disallowEmptySelection: boolean;
+    disallowSelectAll: boolean;
+    expandOn: TreeExpandOn;
+    focusMode: TreeFocusMode;
+    guides: boolean;
+    itemSize: number;
+    loop: boolean;
+    navigateDisabled: boolean;
+    overscan: number;
+    pageSize: number;
+    selectOnFocus: boolean;
+    selectionBehavior: TreeSelectionBehavior;
+    selectionCascade: TreeSelectionCascade;
+    selectionIndicator: TreeSelectionIndicator;
+    selectionMode: TreeSelectionMode;
+    size: TreeSize;
+    structure: TreeStructure;
+    typeahead: boolean;
+    typeaheadTimeout: number;
+    variant: TreeVariant;
+    virtual: boolean;
+}
+declare const TREE_DEFAULTS: InjectionToken<TreeDefaults>;
+/**
+ * An application decides once how its trees behave, rather than repeating
+ * twenty inputs on every hierarchy in a product. A tree that states any of them
+ * itself still wins: an explicit input is never overridden by the token.
+ */
+declare function provideTreeDefaults(defaults: Partial<TreeDefaults>): {
+    provide: InjectionToken<TreeDefaults>;
+    useFactory: () => TreeDefaults;
+};
+/** What a tree behaves as here, before it states anything of its own. */
+declare function injectTreeDefaults(): TreeDefaults;
+/**
+ * `aria-activedescendant` names a node by its id, and a node's own label names
+ * the node, so every node needs two ids and the same strings have to be
+ * produced on the server and in the browser. A counter held by the injector
+ * produces them; `Math.random` would not match for hydration.
+ */
+declare class SlTreeIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * What a part asks the tree around it.
+ *
+ * It is an abstract class rather than an interface so it can be the injection
+ * token as well as the type, and it exists in a file of its own so the parts do
+ * not import the component that renders them: the component's own template
+ * applies the node component, and a direct import each way is a cycle.
+ */
+declare abstract class SlTreeContext {
+    abstract readonly indicatorMode: Signal<Exclude<TreeSelectionIndicator, 'auto'>>;
+    abstract readonly selection: Signal<TreeSelectionMode>;
+    abstract readonly expandOnRow: Signal<TreeExpandOn>;
+    abstract readonly treeDisabled: Signal<boolean>;
+    abstract readonly showGuides: Signal<boolean>;
+    /** Whether this key is chosen. */
+    abstract isSelected(key: string): boolean;
+    /** Whether this branch is open. */
+    abstract isExpanded(key: string): boolean;
+    /** Whether this key is the one the keyboard is on. */
+    abstract isActive(key: string): boolean;
+    /** Whether this branch holds part of a selection and not the whole of it. */
+    abstract isIndeterminate(key: string): boolean;
+    /** Whether this collapsed branch holds a chosen descendant. */
+    abstract holdsSelection(key: string): boolean;
+    /** The id a node carries, so `aria-activedescendant` can name it. */
+    abstract nodeId(key: string): string;
+    /** The id of the node's own label, which is what names the node. */
+    abstract labelId(key: string): string;
+    /** The tab stop under the roving model, and `null` under the other one. */
+    abstract nodeTabIndex(key: string): number | null;
+    /**
+     * The level, the size of the sibling group and the place in it. All three are
+     * `null` unless the flat structure is in force, which is exactly when the
+     * pattern requires them: with the nesting in the DOM the browser computes
+     * them itself.
+     */
+    abstract levelOf(key: string): number | null;
+    abstract setSizeOf(key: string): number | null;
+    abstract posInSetOf(key: string): number | null;
+    /** A press on a row, with the modifiers it was pressed with. */
+    abstract press(key: string, event: MouseEvent): void;
+    /** A press on the chevron, which only ever opens or closes. */
+    abstract pressExpander(key: string, event: MouseEvent): void;
+    /** A press on the box, which only ever selects. */
+    abstract pressIndicator(key: string, event: MouseEvent): void;
+}
+
+/**
+ * What the tree holds: one key in `single` and `none`, a set of them in
+ * `multiple`. The shape `listbox` settled, for the same reason.
+ */
+type TreeValue = string | readonly string[] | null;
+type TreeChangeRequest = ChangeRequest<TreeValue>;
+type TreeExpansionRequest = ChangeRequest<readonly string[]>;
+type TreeActiveRequest = ChangeRequest<string | null>;
+/** One row of the render plan the template walks. */
+interface PlanNode {
+    key: string;
+    item: unknown;
+    label: string;
+    level: number;
+    disabled: boolean;
+    branch: boolean;
+    loading: boolean;
+    match: 'hit' | 'ancestor' | undefined;
+    /** Where a pinned row sits on the canvas, or `undefined` for one in flow. */
+    offset: number | undefined;
+    children: PlanNode[];
+}
+/**
+ * A hierarchy the reader opens, walks and chooses from.
+ *
+ * ── Where the visible list comes from ───────────────────────────────────
+ *
+ * From the DOM, in document order, which is the flattening a tree would
+ * otherwise have to keep in step with the expanded set. A collapsed branch
+ * renders no group and therefore contributes no rows, so what the keyboard
+ * counts and what the reader sees cannot disagree.
+ *
+ * `nodes` is a second thing and not a replacement: it is the hierarchy the tree
+ * holds, and it answers the three questions the DOM cannot — what is under a
+ * branch that is closed, which a cascade needs; what every branch is, which
+ * `expandAll` opens; and what matches a query, whose ancestors the filter
+ * keeps.
+ *
+ * ── Three mutable values ────────────────────────────────────────────────
+ *
+ * The pattern is explicit that focus and selection are two: "DOM focus (the
+ * active element) is functionally distinct from the selected state". Expansion
+ * is the third and belongs to neither.
+ */
+declare class SlTree implements SlTreeContext, ControlValueAccessor, Validator {
+    readonly value: _angular_core.ModelSignal<TreeValue>;
+    readonly expandedKeys: _angular_core.ModelSignal<readonly string[]>;
+    readonly activeKey: _angular_core.ModelSignal<string | null>;
+    /** The request behind each move, carrying the reason a boolean cannot say. */
+    readonly valueRequest: _angular_core.OutputEmitterRef<TreeChangeRequest>;
+    readonly expandedKeysRequest: _angular_core.OutputEmitterRef<TreeExpansionRequest>;
+    readonly activeKeyRequest: _angular_core.OutputEmitterRef<TreeActiveRequest>;
+    /** A node was activated: pressed, or `Enter` on the keyboard. */
+    readonly nodeActivate: _angular_core.OutputEmitterRef<{
+        key: string;
+        reason: "pointer" | "keyboard";
+    }>;
+    private readonly defaults;
+    readonly size: _angular_core.InputSignal<TreeSize>;
+    readonly variant: _angular_core.InputSignal<TreeVariant>;
+    readonly structure: _angular_core.InputSignal<TreeStructure>;
+    readonly selectionMode: _angular_core.InputSignal<TreeSelectionMode>;
+    readonly selectionBehavior: _angular_core.InputSignal<TreeSelectionBehavior>;
+    readonly selectionIndicator: _angular_core.InputSignal<TreeSelectionIndicator>;
+    readonly selectionCascade: _angular_core.InputSignal<TreeSelectionCascade>;
+    readonly expandOn: _angular_core.InputSignal<TreeExpandOn>;
+    readonly focusMode: _angular_core.InputSignal<TreeFocusMode>;
+    readonly guides: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly typeaheadTimeout: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly selectOnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly navigateDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disallowEmptySelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disallowSelectAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pageSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly virtual: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly itemSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly overscan: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
+    readonly nodes: _angular_core.InputSignal<readonly unknown[] | undefined>;
+    readonly getKey: _angular_core.InputSignal<((node: never) => string) | undefined>;
+    readonly getLabel: _angular_core.InputSignal<((node: never) => string) | undefined>;
+    readonly getChildren: _angular_core.InputSignal<((node: never) => readonly unknown[] | undefined) | undefined>;
+    readonly getLevel: _angular_core.InputSignal<((node: never) => number) | undefined>;
+    readonly hasChildren: _angular_core.InputSignal<((node: never) => boolean) | undefined>;
+    readonly getChildrenCount: _angular_core.InputSignal<((node: never) => number | undefined) | undefined>;
+    readonly isNodeDisabled: _angular_core.InputSignal<((node: never) => boolean) | undefined>;
+    readonly isNodeLoading: _angular_core.InputSignal<((node: never) => boolean) | undefined>;
+    /**
+     * A query the tree filters by. The consumer owns the string and the control
+     * it is typed into; the tree keeps the ancestors of every hit.
+     */
+    readonly query: _angular_core.InputSignal<string | undefined>;
+    /** The row's content, re-rendered per node rather than projected once. */
+    protected readonly nodeContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    private readonly host;
+    private readonly ids;
+    private readonly base;
+    private readonly typeaheadHandle;
+    constructor();
+    private measure;
+    readonly selection: _angular_core.Signal<TreeSelectionMode>;
+    readonly treeDisabled: _angular_core.Signal<boolean>;
+    readonly showGuides: _angular_core.Signal<boolean>;
+    readonly expandOnRow: _angular_core.Signal<TreeExpandOn>;
+    /**
+     * `auto` reads the mode beside it: a box for a set the reader ticks, a
+     * highlight for the one thing they chose, and neither when nothing is
+     * selectable. The pattern's own note recommends exactly this convention.
+     */
+    readonly indicatorMode: _angular_core.Signal<"none" | "highlight" | "checkbox">;
+    /**
+     * The flat shape is the windowed one, and it is the handed collection's
+     * alone: a slice of rows cannot preserve nesting, and a node written in a
+     * template cannot render its children as its own siblings.
+     */
+    protected readonly structureMode: _angular_core.Signal<"nested" | "flat">;
+    protected readonly mode: _angular_core.Signal<"roving" | "activedescendant">;
+    private readonly collection;
+    private readonly selected;
+    private readonly filtered;
+    private readonly viewportSize;
+    private readonly scrollOffset;
+    private readonly visible;
+    private readonly windowed;
+    private readonly slice;
+    protected readonly canvasSize: _angular_core.Signal<string | null>;
+    protected readonly canvasOffset: _angular_core.Signal<string | null>;
+    protected onScroll(): void;
+    protected readonly plan: _angular_core.Signal<PlanNode[]>;
+    protected readonly holdsNothing: _angular_core.Signal<boolean>;
+    private readonly positions;
+    private readonly indeterminateSet;
+    isSelected(key: string): boolean;
+    /**
+     * A branch the reader opened, or one a query is holding open.
+     *
+     * A filter that asked for the expansion instead would move the reader's own
+     * set and have to put it back when the query emptied, and a reader who
+     * cleared a search would find branches open that they never opened. Holding
+     * the path open for as long as the query lasts keeps the set the reader owns
+     * untouched, and keeps `aria-expanded` telling the truth about what is on
+     * screen.
+     */
+    isExpanded(key: string): boolean;
+    isActive(key: string): boolean;
+    isIndeterminate(key: string): boolean;
+    holdsSelection(key: string): boolean;
+    nodeId(key: string): string;
+    labelId(key: string): string;
+    nodeTabIndex(key: string): 0 | -1 | null;
+    levelOf(key: string): number | null;
+    setSizeOf(key: string): number | null;
+    posInSetOf(key: string): number | null;
+    protected readonly activeDescendant: _angular_core.Signal<string | null>;
+    protected readonly canvasTabIndex: _angular_core.Signal<0 | -1>;
+    private canvas;
+    private readRows;
+    private parentOf;
+    private renderedDescendants;
+    private anchor;
+    private requestValue;
+    private requestExpanded;
+    private requestActive;
+    private setExpanded;
+    private applySelection;
+    press(key: string, event: MouseEvent): void;
+    pressExpander(key: string, event: MouseEvent): void;
+    pressIndicator(key: string, event: MouseEvent): void;
+    private moveTo;
+    private move;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onFocusIn(event: FocusEvent): void;
+    focus(): void;
+    expand(key: string): void;
+    collapse(key: string): void;
+    expandAll(): void;
+    collapseAll(): void;
+    scrollToKey(key: string, align?: TreeAlignment): void;
+    private readonly formDisabled;
+    private onChange;
+    private onTouched;
+    writeValue(value: TreeValue): void;
+    registerOnChange(fn: (value: TreeValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(state: boolean): void;
+    /**
+     * The family owns validity only for `required`, which is the one rule it can
+     * decide from the value alone: everything else about a hierarchy is the
+     * consumer's own.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTree, "[slTree]", ["slTree"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "expandedKeys": { "alias": "expandedKeys"; "required": false; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "structure": { "alias": "structure"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; "isSignal": true; }; "selectionIndicator": { "alias": "selectionIndicator"; "required": false; "isSignal": true; }; "selectionCascade": { "alias": "selectionCascade"; "required": false; "isSignal": true; }; "expandOn": { "alias": "expandOn"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "guides": { "alias": "guides"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; "typeaheadTimeout": { "alias": "typeaheadTimeout"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "navigateDisabled": { "alias": "navigateDisabled"; "required": false; "isSignal": true; }; "disallowEmptySelection": { "alias": "disallowEmptySelection"; "required": false; "isSignal": true; }; "disallowSelectAll": { "alias": "disallowSelectAll"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "getKey": { "alias": "getKey"; "required": false; "isSignal": true; }; "getLabel": { "alias": "getLabel"; "required": false; "isSignal": true; }; "getChildren": { "alias": "getChildren"; "required": false; "isSignal": true; }; "getLevel": { "alias": "getLevel"; "required": false; "isSignal": true; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "getChildrenCount": { "alias": "getChildrenCount"; "required": false; "isSignal": true; }; "isNodeDisabled": { "alias": "isNodeDisabled"; "required": false; "isSignal": true; }; "isNodeLoading": { "alias": "isNodeLoading"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "expandedKeys": "expandedKeysChange"; "activeKey": "activeKeyChange"; "valueRequest": "valueRequest"; "expandedKeysRequest": "expandedKeysRequest"; "activeKeyRequest": "activeKeyRequest"; "nodeActivate": "nodeActivate"; }, ["nodeContent"], ["*", "[slTreeEmpty]"], true, never>;
+}
+
+/**
+ * One node, and the facts the tree reads back off it.
+ *
+ * The visible collection is read from the DOM rather than from a registry, as
+ * `listbox` and `menu` already do: document order is reading order, a collapsed
+ * branch renders no group and therefore contributes no rows, and nothing has to
+ * be registered, unregistered or ordered by mount time. The flattening a tree
+ * would otherwise need is the browser's own.
+ *
+ * `aria-disabled` and never the native attribute: the pattern needs a disabled
+ * node to keep its place in the set, and `navigateDisabled` is what decides
+ * whether the arrows land on it.
+ */
+declare class SlTreeNode {
+    /** The key this node selects and expands by. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** The node's name, when it is a plain string. */
+    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Whether this node has children that have not been rendered yet. A branch
+     * says so before it can prove it, which is what makes lazy loading possible.
+     */
+    readonly hasChildren: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the children are on their way. Writes `aria-busy` on the group. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Unstated rather than `false`, so the node defers to the tree. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * What typeahead matches and what a reader hears. Defaults to the label's own
+     * text, which is wrong exactly when the label holds a mark or a number.
+     */
+    readonly textValue: _angular_core.InputSignal<string | undefined>;
+    /** Whether a query matched this node's own name or one below it. */
+    readonly match: _angular_core.InputSignal<"hit" | "ancestor" | undefined>;
+    /**
+     * Rendered at its own place on the canvas whether or not the window covers
+     * it. The tree pins the active node and the range anchor; nothing else sets
+     * it, because an `aria-activedescendant` whose target has been recycled names
+     * an id that is not in the document.
+     */
+    readonly pinned: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Where the node sits on the canvas, in pixels. Windowed rows only. */
+    readonly offset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /**
+     * How deep the node sits, stated only by the flat shape. Everywhere else the
+     * markup says it: a node inside another is one level deeper, and the number
+     * is a fact about the tree rather than one more thing a consumer can get
+     * wrong.
+     */
+    readonly level: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    protected readonly tree: SlTreeContext;
+    /**
+     * The node this one is written inside, found through the element injector
+     * rather than through a context signal: projected content keeps the injector
+     * of the place it was declared, which is exactly the nesting the depth is
+     * counted from.
+     */
+    private readonly parent;
+    private readonly host;
+    /**
+     * The nodes this one is rendered inside, counted in the document once it is
+     * attached. A template that calls itself declares every instance at the root,
+     * so the injector finds no parent for any of them and the whole tree would
+     * draw flat; the document still nests them, and so does the level the
+     * platform reports.
+     */
+    private readonly renderedDepth;
+    /**
+     * The nodes written inside this one. Angular creates projected content with
+     * the parent's own view and only decides where to place it, so the query
+     * answers a branch that is closed and whose group is therefore not rendered —
+     * which is what keeps a collapsed branch a branch.
+     */
+    private readonly childNodes;
+    /** A branch is a node that holds children or says it will. */
+    protected readonly branch: Signal<boolean>;
+    /**
+     * Annotated rather than inferred: the depth of a node reads the depth of the
+     * node it is written inside, and an inferred type would be defined in terms
+     * of itself.
+     */
+    readonly depth: Signal<number>;
+    protected readonly expanded: Signal<boolean>;
+    protected readonly selected: Signal<boolean>;
+    protected readonly indeterminate: Signal<boolean>;
+    protected readonly holdsSelection: Signal<boolean>;
+    protected readonly current: Signal<boolean>;
+    protected readonly id: Signal<string>;
+    protected readonly labelId: Signal<string>;
+    protected readonly resolvedDisabled: Signal<boolean>;
+    protected readonly ariaExpanded: Signal<"true" | "false" | null>;
+    private readonly chosen;
+    protected readonly ariaSelected: Signal<"true" | "false" | null>;
+    protected readonly ariaChecked: Signal<"true" | "false" | null>;
+    /**
+     * The level the node reports is the tree's answer and not the depth it was
+     * handed: the depth places the row, and the property is written only where
+     * the nesting no longer says it.
+     */
+    protected readonly levelAttr: Signal<number | null>;
+    protected readonly setSize: Signal<number | null>;
+    protected readonly posInSet: Signal<number | null>;
+    protected readonly tabIndex: Signal<number | null>;
+    constructor();
+    protected onRowClick(event: MouseEvent): void;
+    protected onExpanderClick(event: MouseEvent): void;
+    protected onIndicatorClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTreeNode, "li[slTreeNode]", ["slTreeNode"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "textValue": { "alias": "textValue"; "required": false; "isSignal": true; }; "match": { "alias": "match"; "required": false; "isSignal": true; }; "pinned": { "alias": "pinned"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; }, {}, ["childNodes"], ["[slTreeIcon]", "[slTreeLabel]", "[slTreeDescription]", "[slTreeMeta]", "[slTreeActions]", "[slTreeGroup]", "*"], true, never>;
+}
+/**
+ * The list a branch's children are written in.
+ *
+ * It exists because Angular parses a template as HTML: an `li` closes the `li`
+ * before it, so a node written inside a node needs the list between them. The
+ * node decides whether the group is placed; the consumer decides what element
+ * it is.
+ */
+declare class SlTreeGroup {
+    /** Whether the children are still on their way. */
+    readonly busy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeGroup, "ul[slTreeGroup]", never, { "busy": { "alias": "busy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The node's leading picture, which the consumer owns whole. */
+declare class SlTreeIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeIcon, "[slTreeIcon]", never, {}, {}, never, never, true, never>;
+}
+/** The node's name, when it is richer than a string. */
+declare class SlTreeLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeLabel, "[slTreeLabel]", never, {}, {}, never, never, true, never>;
+}
+/** A second line under the name. */
+declare class SlTreeDescription {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeDescription, "[slTreeDescription]", never, {}, {}, never, never, true, never>;
+}
+/** The trailing count, size or badge. */
+declare class SlTreeMeta {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeMeta, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeMeta, "[slTreeMeta]", never, {}, {}, never, never, true, never>;
+}
+/** The trailing controls. They stay in the DOM and stay reachable. */
+declare class SlTreeActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeActions, "[slTreeActions]", never, {}, {}, never, never, true, never>;
+}
+/** What the tree shows when it holds nothing. */
+declare class SlTreeEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTreeEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTreeEmpty, "[slTreeEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+export { SlTree, SlTreeActions, SlTreeContext, SlTreeDescription, SlTreeEmpty, SlTreeGroup, SlTreeIcon, SlTreeIdFactory, SlTreeLabel, SlTreeMeta, SlTreeNode, TREE_DEFAULTS, injectTreeDefaults, provideTreeDefaults };
+export type { TreeActiveRequest, TreeAlignment, TreeChangeRequest, TreeDefaults, TreeExpandOn, TreeExpansionRequest, TreeFocusMode, TreeSelectionBehavior, TreeSelectionCascade, TreeSelectionIndicator, TreeSelectionMode, TreeSize, TreeStructure, TreeValue, TreeVariant };
+//# sourceMappingURL=slotted-angular-tree.d.ts.map

package/types/slotted-angular-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-tree.d.ts","sources":["../../tree/src/tree-defaults.ts","../../tree/src/tree-context.ts","../../tree/src/tree.ts","../../tree/src/tree-parts.ts"],"mappings":"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","names":[]}

package/types/slotted-angular-typography.d.ts

@@ -0,0 +1,89 @@
+import * as _angular_core from '@angular/core';
+
+type TypographySize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+type TypographyWeight = 'regular' | 'medium' | 'semibold';
+type TypographyTone = 'inherit' | 'default' | 'muted' | 'accent' | 'success' | 'warning' | 'danger' | 'inverse';
+type TypographyAlign = 'start' | 'center' | 'end';
+type TypographyWrap = 'normal' | 'nowrap' | 'balance' | 'pretty';
+type TypographyTransform = 'none' | 'uppercase' | 'capitalize';
+type TypographyNumeric = 'normal' | 'tabular';
+/** The six the platform has. A seventh would be a heading no browser knows. */
+type HeadingLevelValue = 1 | 2 | 3 | 4 | 5 | 6;
+
+/**
+ * A heading is a rank in the document outline and a size on the page, and the
+ * two are separate. The rank is the element the consumer wrote, because that
+ * is where the platform keeps it; the size follows the rank until `size` asks
+ * for another.
+ *
+ * The section the heading sits in states the rank it expects, and a heading
+ * more than one rank deeper than that has skipped one. The skip is reported,
+ * never corrected: the element the consumer wrote is the element rendered.
+ */
+declare class SlHeading {
+    readonly align: _angular_core.InputSignal<TypographyAlign | undefined>;
+    readonly numeric: _angular_core.InputSignal<TypographyNumeric | undefined>;
+    readonly size: _angular_core.InputSignal<TypographySize | undefined>;
+    readonly tone: _angular_core.InputSignal<TypographyTone | undefined>;
+    readonly transform: _angular_core.InputSignal<TypographyTransform | undefined>;
+    readonly truncate: _angular_core.InputSignal<number | boolean | undefined>;
+    readonly weight: _angular_core.InputSignal<TypographyWeight>;
+    readonly wrap: _angular_core.InputSignal<TypographyWrap>;
+    private readonly element;
+    private readonly section;
+    /** The rank of the element the consumer wrote, which the tag already states. */
+    readonly level: HeadingLevelValue;
+    protected readonly resolvedSize: _angular_core.Signal<TypographySize>;
+    protected readonly toneAttribute: _angular_core.Signal<string | null>;
+    protected readonly lines: _angular_core.Signal<number | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlHeading, "h1[slHeading],h2[slHeading],h3[slHeading],h4[slHeading],h5[slHeading],h6[slHeading]", ["slHeading"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; "numeric": { "alias": "numeric"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * One section deeper. A heading inside takes the next rank, which is how the
+ * outline stays correct in a tree assembled from components that cannot see
+ * each other: the HTML Standard requires each heading to be less than, equal
+ * to, or one greater than the heading before it, and stepping by exactly one
+ * is the only way to guarantee that without reading the document.
+ *
+ * The directive sits on the element the consumer already wrote for the
+ * section, so it adds nothing to the DOM. The depth is fixed for the life of
+ * the element, so it is a value rather than a signal.
+ */
+declare class SlHeadingLevel {
+    private readonly parent;
+    readonly level: HeadingLevelValue;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlHeadingLevel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlHeadingLevel, "[slHeadingLevel]", ["slHeadingLevel"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Text sets the library's type on the element the consumer already wrote. The
+ * directive makes no claim about which element that is: a paragraph, a label
+ * or a table cell is a claim the consumer makes by writing the tag.
+ *
+ * An axis reaches the stylesheet only when someone decided it. The base rule
+ * already paints the family default, and text is the most numerous element in
+ * any document.
+ */
+declare class SlText {
+    readonly align: _angular_core.InputSignal<TypographyAlign | undefined>;
+    readonly numeric: _angular_core.InputSignal<TypographyNumeric | undefined>;
+    readonly size: _angular_core.InputSignal<TypographySize | undefined>;
+    readonly tone: _angular_core.InputSignal<TypographyTone | undefined>;
+    readonly transform: _angular_core.InputSignal<TypographyTransform | undefined>;
+    readonly truncate: _angular_core.InputSignal<number | boolean | undefined>;
+    readonly weight: _angular_core.InputSignal<TypographyWeight | undefined>;
+    readonly wrap: _angular_core.InputSignal<TypographyWrap | undefined>;
+    protected readonly toneAttribute: _angular_core.Signal<string | null>;
+    protected readonly lines: _angular_core.Signal<number | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlText, "[slText]", ["slText"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; "numeric": { "alias": "numeric"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SlHeading, SlHeadingLevel, SlText };
+export type { HeadingLevelValue, TypographyAlign, TypographyNumeric, TypographySize, TypographyTone, TypographyTransform, TypographyWeight, TypographyWrap };
+//# sourceMappingURL=slotted-angular-typography.d.ts.map

package/types/slotted-angular-typography.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-typography.d.ts","sources":["../../typography/src/typography.ts","../../typography/src/heading.ts","../../typography/src/heading-level.ts","../../typography/src/text.ts"],"mappings":";;KAAY,cAAc;AACpB,KAAM,gBAAgB;KAChB,cAAc;AAEpB,KAAM,eAAe;AACrB,KAAM,cAAc;AACpB,KAAM,mBAAmB;KACnB,iBAAiB;AAE7B;AACM,KAAM,iBAAiB;;ACwB7B;;;;;;;;;AASG;AACH,cAsBa,SAAS;oBACN,aAAA,CAAA,WAAA,CAAA,eAAA;sBACE,aAAA,CAAA,WAAA,CAAA,iBAAA;mBACH,aAAA,CAAA,WAAA,CAAA,cAAA;mBACA,aAAA,CAAA,WAAA,CAAA,cAAA;wBACK,aAAA,CAAA,WAAA,CAAA,mBAAA;uBACD,aAAA,CAAA,WAAA;qBACF,aAAA,CAAA,WAAA,CAAA,gBAAA;mBACF,aAAA,CAAA,WAAA,CAAA,cAAA;AAEb;AACA;;AAGA,oBAA0D,iBAAiB;AAE3E,qCAA+B,aAAA,CAAA,MAAA,CAAA,cAAA;AAC/B,sCAAgC,aAAA,CAAA,MAAA;AAChC,8BAAwB,aAAA,CAAA,MAAA;;oDAlBb,SAAS;sDAAT,SAAS;AA6BrB;;AC3FD;;;;;;;;;;AAUG;AACH,cAKa,cAAc;AACzB;AAEA,oBAAgB,iBAAiB;;oDAHtB,cAAc;sDAAd,cAAc;AAe1B;;AChBD;;;;;;;;AAQG;AACH,cAsBa,MAAM;oBACH,aAAA,CAAA,WAAA,CAAA,eAAA;sBACE,aAAA,CAAA,WAAA,CAAA,iBAAA;mBACH,aAAA,CAAA,WAAA,CAAA,cAAA;mBACA,aAAA,CAAA,WAAA,CAAA,cAAA;wBACK,aAAA,CAAA,WAAA,CAAA,mBAAA;uBACD,aAAA,CAAA,WAAA;qBACF,aAAA,CAAA,WAAA,CAAA,gBAAA;mBACF,aAAA,CAAA,WAAA,CAAA,cAAA;AAEb,sCAAgC,aAAA,CAAA,MAAA;AAChC,8BAAwB,aAAA,CAAA,MAAA;oDAXb,MAAM;sDAAN,MAAM;AAYlB;;","names":[]}