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

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

@@ -0,0 +1,252 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { MenuAlign, MenuSide, MenuSize } from '@slotted/angular/menu';
+
+/** Which way the bar runs. */
+type ToolbarOrientation = 'horizontal' | 'vertical';
+/** The step the bar's own inset, gap and separator sit at. */
+type ToolbarSize = 'sm' | 'md' | 'lg';
+/** Whether the bar paints a ground of its own. */
+type ToolbarVariant = 'plain' | 'outline';
+/**
+ * What a bar does with more controls than it has room for. `wrap` keeps every
+ * one of them visible on a second row, and the arrows wrap from row to row
+ * because the item list is linear.
+ */
+type ToolbarOverflowMode = 'wrap' | 'scroll' | 'menu';
+interface ToolbarDefaults {
+    loop: boolean;
+    orientation: ToolbarOrientation;
+    overflow: ToolbarOverflowMode;
+    size: ToolbarSize;
+    variant: ToolbarVariant;
+}
+declare const TOOLBAR_DEFAULTS: InjectionToken<ToolbarDefaults>;
+/**
+ * An application decides once how its bars are drawn and how they behave — a
+ * product whose bars are all framed and compact says so in one place rather
+ * than on every bar. A bar that states any of them itself still wins.
+ */
+declare function provideToolbarDefaults(defaults: Partial<ToolbarDefaults>): {
+    provide: InjectionToken<ToolbarDefaults>;
+    useFactory: () => ToolbarDefaults;
+};
+/** What a toolbar renders as here, before it states anything of its own. */
+declare function injectToolbarDefaults(): ToolbarDefaults;
+
+/**
+ * The accessible name of the control that holds what did not fit. A string is
+ * used verbatim; a function is given the number of units behind the control,
+ * because three dots say nothing about how much is behind them.
+ */
+type ToolbarOverflowLabel = string | ((hidden: number) => string);
+/**
+ * One unit that gave way, in the order the bar held it.
+ *
+ * `separatorBefore` is derived rather than declared: the bar is the participant
+ * that hid the units, so it is the only one that knows which of its own rules
+ * are now dividing two things that are both in the surface.
+ */
+interface ToolbarCollapsedUnit {
+    readonly id: string;
+    readonly separatorBefore: boolean;
+}
+/** The attribute that says a unit has somewhere to go. */
+declare const TOOLBAR_UNIT_ATTRIBUTE = "data-unit";
+/**
+ * A set of controls that share one tab stop.
+ *
+ * **The keyboard is the whole point of the role.** `Tab` enters the bar once and
+ * lands on the control that last had focus, the arrows of the flow axis move
+ * between the controls and wrap — from row to row when the bar wrapped, because
+ * the item list is linear — and `Home` and `End` reach the ends. The cross axis
+ * duplicates the pair, which the APG permits and which is what gives focus a way
+ * out of an item that keeps the flow arrows for itself.
+ *
+ * **The items are the consumer's own controls.** Anything focusable inside the
+ * bar is an item, found through `TOOLBAR_ITEM_SELECTOR`, so this library's
+ * `button`, `link`, `checkbox`, `switch` and `text-field` — and a menu trigger,
+ * and a consumer's own control — drop in unwrapped.
+ *
+ * **The bar paints itself and nothing inside it.** A bar out of action is
+ * `<fieldset disabled>` around it: the platform disables every control inside,
+ * and a natively disabled control cannot be focused, so the arrows skip exactly
+ * those.
+ */
+declare class SlToolbar {
+    readonly orientation: _angular_core.InputSignal<ToolbarOrientation | undefined>;
+    readonly size: _angular_core.InputSignal<ToolbarSize | undefined>;
+    readonly variant: _angular_core.InputSignal<ToolbarVariant | undefined>;
+    readonly overflow: _angular_core.InputSignal<ToolbarOverflowMode | undefined>;
+    /** Whether the arrows wrap past the ends of the bar. */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Reports how many units gave way, once per change. The collapsed set is a
+     * measurement rather than a value, so there is no two-way binding over it: a
+     * consumer who owned it could assert that a bar fits when the layout says it
+     * does not.
+     */
+    readonly overflowChange: _angular_core.OutputEmitterRef<number>;
+    private readonly defaults;
+    private readonly element;
+    private readonly counterparts;
+    private readonly trigger;
+    private readonly ready;
+    private ring;
+    /** The units that gave way, in the order the bar held them. */
+    readonly collapsedUnits: _angular_core.WritableSignal<readonly ToolbarCollapsedUnit[]>;
+    readonly resolvedOrientation: _angular_core.Signal<ToolbarOrientation>;
+    readonly resolvedSize: _angular_core.Signal<ToolbarSize>;
+    readonly resolvedVariant: _angular_core.Signal<ToolbarVariant>;
+    readonly resolvedOverflow: _angular_core.Signal<ToolbarOverflowMode>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    protected readonly ariaOrientation: _angular_core.Signal<"vertical" | null>;
+    protected readonly collapsedCount: _angular_core.Signal<string | null>;
+    /** Records what a unit becomes in the surface. */
+    registerUnit(id: string, template: TemplateRef<unknown>): void;
+    releaseUnit(id: string): void;
+    counterpart(id: string): TemplateRef<unknown> | null;
+    /** The control that opens what did not fit. The bar measures it. */
+    registerTrigger(element: HTMLElement | null): void;
+    constructor();
+    private collapse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToolbar, "[slToolbar]", ["slToolbar"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "overflowChange": "overflowChange"; }, never, ["*"], true, never>;
+}
+/**
+ * A run of related controls, announced as a group.
+ *
+ * The distance inside it is half the bar's gap and the distance around it is a
+ * gap and a half, so the boundary between two groups reads wider than the
+ * boundary between two controls. Its accessible name is the consumer's own
+ * `aria-label`.
+ *
+ * The arrows do not stop at its edge: a group is a label around a run, not a
+ * second keyboard.
+ */
+declare class SlToolbarGroup {
+    /**
+     * What the whole run becomes when the bar has no room for it, under
+     * `overflow="menu"`. A group that declares none is pinned.
+     */
+    readonly counterpart: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected readonly unit: {
+        id: _angular_core.Signal<string | null>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbarGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToolbarGroup, "[slToolbarGroup]", ["slToolbarGroup"], { "counterpart": { "alias": "slToolbarGroupCounterpart"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One unit the bar may give up, and what it becomes when it does.
+ *
+ * A unit is a direct child of the root, which is deliberately not the same
+ * thing as an item: the keyboard finds items by being focusable, at any depth,
+ * and the collapse acts on the boxes the bar lays out. A `slButtonGroup` inside
+ * one of these is one unit and four items.
+ *
+ * It is only needed under `overflow="menu"`, and only around a control the bar
+ * is allowed to hide. A control placed in a bar unwrapped is a unit too — a
+ * pinned one, because it declares nothing to become.
+ */
+declare class SlToolbarItem {
+    /**
+     * What the control becomes in the surface. An item that declares none cannot
+     * be hidden, which is how a primary action stays visible: it has nowhere to
+     * go, rather than a rank above the others.
+     */
+    readonly counterpart: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected readonly unit: {
+        id: _angular_core.Signal<string | null>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbarItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToolbarItem, "[slToolbarItem]", ["slToolbarItem"], { "counterpart": { "alias": "slToolbarItemCounterpart"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A hairline between two runs.
+ *
+ * It is a part of this family rather than a `divider`, because its geometry
+ * belongs to the bar: it is measured against the controls beside it, and it
+ * turns with the bar. `aria-orientation` states the axis of the rule itself,
+ * which is perpendicular to the one the controls run along.
+ */
+declare class SlToolbarSeparator {
+    private readonly toolbar;
+    protected readonly ariaOrientation: _angular_core.Signal<"horizontal" | "vertical">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbarSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToolbarSeparator, "[slToolbarSeparator]", ["slToolbarSeparator"], {}, {}, never, never, true, never>;
+}
+/**
+ * The free space between two runs, so what follows sits at the end of the bar.
+ *
+ * It replaces a `justify` axis: an axis decides the placement of every control
+ * at once, and what a bar needs is one boundary — the editing controls at the
+ * start, the destructive one at the end.
+ */
+declare class SlToolbarSpacer {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbarSpacer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToolbarSpacer, "[slToolbarSpacer]", ["slToolbarSpacer"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The control that opens what did not fit, and the surface holding it.
+ *
+ * It is `menu`'s own trigger and surface wearing this family's geometry, so the
+ * keyboard, the dismissal and the focus return are `menu`'s and are not written
+ * twice. What this family adds is the measurement: the bar decides which units
+ * give way, and the counterparts they declared are rendered here in the order
+ * the bar held them, with a separator wherever one of the bar's own rules sat
+ * between two of them.
+ *
+ * The counterpart is an `ng-template` rendered through `NgTemplateOutlet` only
+ * while its unit is collapsed, so a menu item that is never reached builds
+ * nothing. That is where the two bindings differ most, and it is idiom rather
+ * than asymmetry: React's `ReactNode` is built with the element that declares
+ * it, which is React's own answer and its own cost.
+ *
+ * **A template resolves its dependencies where it was written, not where it is
+ * rendered.** The counterpart is authored beside the control it replaces, which
+ * is outside the surface, so `slMenuItem` looked for the `SlMenu` above the bar
+ * and found none — `NG0201`. The outlet is therefore given an injector that
+ * provides the surface this component draws, and the item finds the menu it is
+ * actually inside. The DOM was never wrong; only the injector was.
+ *
+ * The host is `display: contents`, so the `button` below is a child of the bar
+ * itself: the part that carries the geometry has to be the box the bar lays
+ * out, and a wrapper between them would be a unit the collapse would try to
+ * measure.
+ *
+ * **The `hidden` attribute on the trigger belongs to the bar.** `createCollapse`
+ * writes it, because the same measurement that decides whether the control is
+ * needed is the one that has to reveal it to read its width.
+ */
+declare class SlToolbarOverflow {
+    /** Where the surface sits against the trigger. */
+    readonly align: _angular_core.InputSignal<MenuAlign | undefined>;
+    readonly side: _angular_core.InputSignal<MenuSide | undefined>;
+    /** The surface's own measure, which is `menu`'s axis rather than the bar's. */
+    readonly size: _angular_core.InputSignal<MenuSize | undefined>;
+    /**
+     * The accessible name. Defaults to a count — "3 more actions" — because the
+     * mark says nothing about how much is behind it.
+     */
+    readonly label: _angular_core.InputSignal<ToolbarOverflowLabel | undefined>;
+    protected readonly toolbar: SlToolbar;
+    /** A name the consumer wrote on the host survives the counted default. */
+    private readonly stated;
+    protected readonly name: _angular_core.Signal<string>;
+    private readonly trigger;
+    private readonly surface;
+    private readonly injector;
+    /**
+     * `null` until the view exists, which is also while nothing has collapsed and
+     * the outlet renders nothing.
+     */
+    protected readonly surfaceInjector: _angular_core.Signal<_angular_core.DestroyableInjector | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToolbarOverflow, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToolbarOverflow, "sl-toolbar-overflow", ["slToolbarOverflow"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SlToolbar, SlToolbarGroup, SlToolbarItem, SlToolbarOverflow, SlToolbarSeparator, SlToolbarSpacer, TOOLBAR_DEFAULTS, TOOLBAR_UNIT_ATTRIBUTE, injectToolbarDefaults, provideToolbarDefaults };
+export type { ToolbarCollapsedUnit, ToolbarDefaults, ToolbarOrientation, ToolbarOverflowLabel, ToolbarOverflowMode, ToolbarSize, ToolbarVariant };
+//# sourceMappingURL=slotted-angular-toolbar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-toolbar.d.ts","sources":["../../toolbar/src/toolbar-defaults.ts","../../toolbar/src/toolbar.ts","../../toolbar/src/toolbar-overflow.ts"],"mappings":";;;;AAEA;KACY,kBAAkB;AAE9B;AACM,KAAM,WAAW;AAEvB;KACY,cAAc;AAE1B;;;;AAIG;AACG,KAAM,mBAAmB;UAEd,eAAe;;iBAEjB,kBAAkB;cACrB,mBAAmB;UACvB,WAAW;aACR,cAAc;AACxB;AAUD,cAAa,gBAAgB,EAAA,cAAA,CAAA,eAAA;AAK7B;;;;AAIG;AACH,iBAAgB,sBAAsB,WAAW,OAAO,CAAC,eAAe;;sBAGpD,eAAe;AAElC;AAED;AACA,iBAAgB,qBAAqB,IAAI,eAAe;;ACdxD;;;;AAIG;AACG,KAAM,oBAAoB;AAEhC;;;;;;AAMG;UACc,oBAAoB;AACnC;AACA;AACD;AAED;AACA,cAAa,sBAAsB;AAgCnC;;;;;;;;;;;;;;;;;;;AAmBG;AACH,cAoBa,SAAS;0BACA,aAAA,CAAA,WAAA,CAAA,kBAAA;mBACP,aAAA,CAAA,WAAA,CAAA,WAAA;sBACG,aAAA,CAAA,WAAA,CAAA,cAAA;uBACC,aAAA,CAAA,WAAA,CAAA,mBAAA;;mBAEJ,aAAA,CAAA,wBAAA;AAIb;;;;;AAKG;6BACoB,aAAA,CAAA,gBAAA;AAEvB;AACA;AAEA;AACA;AACA;;;6BAIuB,aAAA,CAAA,cAAA,UAAA,oBAAA;kCAEK,aAAA,CAAA,MAAA,CAAA,kBAAA;2BACP,aAAA,CAAA,MAAA,CAAA,WAAA;8BACG,aAAA,CAAA,MAAA,CAAA,cAAA;+BACC,aAAA,CAAA,MAAA,CAAA,mBAAA;2BACJ,aAAA,CAAA,MAAA;AAErB,wCAAkC,aAAA,CAAA,MAAA;AAIlC,uCAAiC,aAAA,CAAA,MAAA;;uCAKE,WAAW;;6BAYxB,WAAA;;AAKtB,6BAAyB,WAAW;;;oDA7DzB,SAAS;sDAAT,SAAS;AAqJrB;AAED;;;;;;;;;;AAUG;AACH,cAMa,cAAc;AACzB;;;AAGG;0BACiB,aAAA,CAAA,WAAA,CAAA,WAAA;;;AAI4C;oDATrD,cAAc;sDAAd,cAAc;AAU1B;AAED;;;;;;;;;;;AAWG;AACH,cAMa,aAAa;AACxB;;;;AAIG;0BACiB,aAAA,CAAA,WAAA,CAAA,WAAA;;;AAI4C;oDAVrD,aAAa;sDAAb,aAAa;AAWzB;AA+BD;;;;;;;AAOG;AACH,cAUa,kBAAkB;AAC7B;AAEA,wCAAkC,aAAA,CAAA,MAAA;oDAHvB,kBAAkB;sDAAlB,kBAAkB;AAM9B;AAED;;;;;;AAMG;AACH,cAMa,eAAe;oDAAf,eAAe;sDAAf,eAAe;AAAG;;ACnY/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH,cA8Ba,iBAAiB;;oBAEd,aAAA,CAAA,WAAA,CAAA,SAAA;mBACD,aAAA,CAAA,WAAA,CAAA,QAAA;;mBAEA,aAAA,CAAA,WAAA,CAAA,QAAA;AACb;;;AAGG;oBACW,aAAA,CAAA,WAAA,CAAA,oBAAA;AAEd,gCAA0B,SAAA;;AAG1B;AAEA,6BAAuB,aAAA,CAAA,MAAA;AASvB;AACA;AACA;AAEA;;;AAGG;AACH,wCAAkC,aAAA,CAAA,MAAA,CAAA,aAAA,CAAA,mBAAA;;oDAlCvB,iBAAiB;sDAAjB,iBAAiB;AAoE7B;;","names":[]}

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

@@ -0,0 +1,388 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/**
+ * How the hint is painted. `inverse` is a surface opposite to the page, which
+ * separates itself in every scheme without an edge; `surface` is the raised
+ * panel with a hairline, for a page that is already dark.
+ */
+type TooltipVariant = 'inverse' | 'surface';
+/** The type step the hint is set at. Both move with density. */
+type TooltipSize = 'sm' | 'md';
+/**
+ * What the tooltip is to its trigger. `description` writes `aria-describedby`;
+ * `label` writes `aria-labelledby` instead, which is the icon-only button whose
+ * only words are the tooltip's — described by it and named by nothing, that
+ * button is announced as "button".
+ *
+ * `none` writes neither and hides the content from the reader: the hint that
+ * repeats words the trigger already carries is read twice under either
+ * reference.
+ */
+type TooltipDescribes = 'description' | 'label' | 'none';
+/** What opens it. `hover` also opens on keyboard focus, and instantly. */
+type TooltipOpenOn = 'hover' | 'focus' | 'manual';
+/** The edge of the anchor the layer prefers. The two logical values mirror. */
+type TooltipSide = 'top' | 'bottom' | 'inline-start' | 'inline-end' | 'left' | 'right';
+/** Where the layer sits along the side it took. */
+type TooltipAlign = 'start' | 'center' | 'end';
+/** When the layer exists. `describes="label"` forces `eager`. */
+type TooltipMount = 'active' | 'lazy' | 'eager';
+/** `fixed` for a layer inside `overflow: hidden`, `absolute` for one inside a transform. */
+type TooltipStrategy = 'absolute' | 'fixed';
+/**
+ * What `openChangeRequest` carries: the value asked for, the previous one, the
+ * reason, the originating event and `cancel()`. The name React's binding gives
+ * the same request.
+ */
+type TooltipChangeRequest = ChangeRequest<boolean>;
+/** Why the hint opened or closed. */
+type TooltipOpenReason = Extract<ChangeRequest<boolean>['reason'], 'pointer' | 'keyboard' | 'escape' | 'blur' | 'programmatic'>;
+/** What an application sets once for every tooltip under it. */
+interface TooltipDefaults {
+    align: TooltipAlign;
+    alignOffset: number;
+    arrow: boolean;
+    arrowPadding: number;
+    closeDelay: number;
+    closeOnPress: boolean;
+    collisionPadding: number;
+    describes: TooltipDescribes;
+    flip: boolean;
+    groupDelay: number;
+    hideWhenDetached: boolean;
+    hoverable: boolean;
+    mount: TooltipMount;
+    openDelay: number;
+    openOn: TooltipOpenOn;
+    portal: boolean;
+    shift: boolean;
+    side: TooltipSide;
+    sideOffset: number;
+    size: TooltipSize;
+    strategy: TooltipStrategy;
+    touchDelay: number;
+    variant: TooltipVariant;
+    /** Opens only while the trigger's own content is cut by its box. */
+    whenClipped: boolean;
+}
+/**
+ * The numbers, and why they are these numbers.
+ *
+ * `openDelay` is long enough that a pointer crossing a toolbar opens nothing
+ * and short enough that a deliberate hover is answered; `closeDelay` is the
+ * window the pointer has to travel onto the layer, and zero makes a hoverable
+ * tooltip unreachable; `groupDelay` is what stops a row of icon buttons
+ * charging the warmup once per button.
+ */
+declare const TOOLTIP_FALLBACK: TooltipDefaults;
+declare const TOOLTIP_DEFAULTS: InjectionToken<TooltipDefaults>;
+/**
+ * When the last tooltip in this injector closed. A tooltip asked to open inside
+ * `groupDelay` of that moment opens in the same task, so reading a row of icon
+ * buttons pays the warmup once. It is held per injector rather than per
+ * tooltip, because a value held per tooltip could not say what "the next one"
+ * means.
+ */
+declare class SlTooltipGroup {
+    lastClosedAt: number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipGroup, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * An application decides once how its tooltips behave and look. A tooltip that
+ * states any of them itself still wins.
+ *
+ * What is stated here is written over the defaults already in force rather than
+ * over the fallback, which is what React's provider does and what a family that
+ * sets two axes for itself needs: a column header asking for `describes="none"`
+ * would otherwise hand the application's own delays back to the fallback.
+ *
+ * The group is provided beside the defaults, so a component that sets its own
+ * defaults also gets its own warmup window — the same scoping React's provider
+ * gives.
+ */
+declare function provideTooltipDefaults(defaults: Partial<TooltipDefaults>): Provider[];
+/** What a tooltip renders as here, before it states anything of its own. */
+declare function injectTooltipDefaults(): TooltipDefaults;
+/**
+ * Where every layer is rendered, for the whole application. It calls
+ * `setPortalContainer` from `@slotted/core/portal`, which is per document, so
+ * an application shell that builds its own stacking context names it once.
+ */
+declare function provideSlottedPortalContainer(container: () => Element | null): Provider;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the server and the client sequences have to
+ * match for hydration.
+ */
+declare class SlTooltipIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * A short, non-interactive sentence about the element under the pointer or
+ * under focus.
+ *
+ * It is written on an `ng-container`, because it renders nothing: the trigger
+ * stays where the consumer wrote it and the layer is portalled to the end of
+ * the document, so no one element could hold both. What it holds is the state,
+ * the delays, and the values every part reads.
+ *
+ * The layer never takes focus and never holds a control. The APG's tooltip
+ * pattern says so, and names the non-modal dialog for the other case, which is
+ * `slPopover`.
+ */
+declare class SlTooltip implements OnInit {
+    /** Whether the hint is showing. Two-way, so a template may bind it directly. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** The state an uncontrolled tooltip starts in, read once in `ngOnInit`. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The tooltip never opens. The trigger's own `disabled` is the consumer's. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Opens only while the trigger's own content is cut by its box — a column
+     * header narrowed to `Op…`, a breadcrumb in a rail. The measurement is taken
+     * at the moment the hint would open, so a column dragged wider stops opening
+     * one without anything being told.
+     */
+    readonly whenClipped: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly variant: _angular_core.InputSignal<TooltipVariant | undefined>;
+    readonly size: _angular_core.InputSignal<TooltipSize | undefined>;
+    readonly describes: _angular_core.InputSignal<TooltipDescribes | undefined>;
+    readonly openOn: _angular_core.InputSignal<TooltipOpenOn | undefined>;
+    readonly side: _angular_core.InputSignal<TooltipSide | undefined>;
+    readonly align: _angular_core.InputSignal<TooltipAlign | undefined>;
+    readonly mount: _angular_core.InputSignal<TooltipMount | undefined>;
+    readonly strategy: _angular_core.InputSignal<TooltipStrategy | undefined>;
+    readonly arrow: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hoverable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnPress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly flip: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly shift: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly portal: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly openDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly touchDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<TooltipChangeRequest>;
+    private readonly defaults;
+    private readonly group;
+    private readonly destroyRef;
+    readonly contentId: string;
+    /** The elements the parts register, which the layer measures and listens to. */
+    readonly triggerNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly arrowNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly resolvedVariant: _angular_core.Signal<TooltipVariant>;
+    readonly resolvedSize: _angular_core.Signal<TooltipSize>;
+    readonly resolvedDescribes: _angular_core.Signal<TooltipDescribes>;
+    readonly resolvedWhenClipped: _angular_core.Signal<boolean>;
+    readonly resolvedOpenOn: _angular_core.Signal<TooltipOpenOn>;
+    readonly resolvedSide: _angular_core.Signal<TooltipSide>;
+    readonly resolvedAlign: _angular_core.Signal<TooltipAlign>;
+    readonly resolvedStrategy: _angular_core.Signal<TooltipStrategy>;
+    readonly resolvedArrow: _angular_core.Signal<boolean>;
+    readonly resolvedHoverable: _angular_core.Signal<boolean>;
+    readonly resolvedCloseOnPress: _angular_core.Signal<boolean>;
+    readonly resolvedFlip: _angular_core.Signal<boolean>;
+    readonly resolvedShift: _angular_core.Signal<boolean>;
+    readonly resolvedHideWhenDetached: _angular_core.Signal<boolean>;
+    readonly resolvedPortal: _angular_core.Signal<boolean>;
+    readonly resolvedSideOffset: _angular_core.Signal<number>;
+    readonly resolvedAlignOffset: _angular_core.Signal<number>;
+    readonly resolvedCollisionPadding: _angular_core.Signal<number>;
+    readonly resolvedArrowPadding: _angular_core.Signal<number>;
+    /**
+     * Under `label` the layer is the trigger's accessible name, so it has to be
+     * in the document before it is ever opened. Forcing the axis is deliberate:
+     * the alternative is a button silently announced as "button".
+     */
+    readonly resolvedMount: _angular_core.Signal<TooltipMount>;
+    private readonly everOpened;
+    readonly seen: _angular_core.Signal<boolean>;
+    /**
+     * One timer for the whole family. An open waiting on `openDelay`, a close
+     * waiting on `closeDelay` and a long press waiting on `touchDelay` are never
+     * pending at once — each cancels the others.
+     */
+    private timer;
+    constructor();
+    /**
+     * Read here rather than in the constructor, because inputs are not set yet
+     * there, and once: a later change to it is not new state.
+     */
+    ngOnInit(): void;
+    cancelPending(): void;
+    /** Opens after `openDelay`, or in the same task inside the group window. */
+    openAfterDelay(source?: Event): void;
+    /** Closes after `closeDelay`, which is the window the pointer has to reach the layer. */
+    closeAfterDelay(source?: Event): void;
+    /** A coarse pointer has no hover, so a press held still opens the hint. */
+    pressAndHold(source?: Event): void;
+    /** Opens now, ignoring every delay. One of the two imperative actions. */
+    show(): void;
+    /** Closes now. */
+    hide(): void;
+    toggle(next: boolean, reason: TooltipOpenReason, source?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTooltip, "[slTooltip]", ["slTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "whenClipped": { "alias": "whenClipped"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "describes": { "alias": "describes"; "required": false; "isSignal": true; }; "openOn": { "alias": "openOn"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "strategy": { "alias": "strategy"; "required": false; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "closeOnPress": { "alias": "closeOnPress"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "touchDelay": { "alias": "touchDelay"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openChangeRequest": "openChangeRequest"; }, never, never, true, never>;
+}
+
+/**
+ * The element the hint is about.
+ *
+ * The directive goes on the consumer's own control, which is what this
+ * ecosystem composes with. It writes the ARIA relationship and `data-open` and
+ * **no `data-part`**: `data-part` names a part of the family that owns the
+ * element, and sixteen stylesheets in this repository key on
+ * `[data-part='root']`, so claiming a `slBadge` or a `slCheckbox` used as a
+ * trigger would unstyle it and nothing would report it.
+ *
+ * A control the page disabled with the native attribute fires no pointer events
+ * at all, so the one explanation of why it is disabled would be unreachable.
+ * The reference page shows the two shapes that work: `aria-disabled` on a
+ * control that stays focusable, or a wrapping element carrying the trigger.
+ */
+declare class SlTooltipTrigger {
+    protected readonly tooltip: SlTooltip;
+    private readonly native;
+    private holding;
+    /**
+     * Named by the layer under `label`, described by it otherwise. Under `none`
+     * the trigger references nothing: it already says the words.
+     */
+    private readonly names;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    constructor();
+    protected onPointerEnter(event: PointerEvent): void;
+    protected onPointerLeave(event: PointerEvent): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerRelease(): void;
+    /**
+     * `:focus-visible` rather than every focus. A pointer press focuses a button
+     * too, and a tooltip opened by it would arrive before the delay it was given
+     * and stay after the press that was meant to dismiss it.
+     */
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    /**
+     * A click synthesised by the keyboard reports no detail; a real one reports
+     * the click count. It is how `Enter` and `Space` are told from a press
+     * without a key listener existing for either.
+     */
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTooltipTrigger, "[slTooltipTrigger]", ["slTooltipTrigger"], {}, {}, never, never, true, never>;
+}
+/**
+ * The positioned layer, built from a template rather than from an element.
+ *
+ * `mount="active"` means the layer exists only while it is open, and a
+ * component cannot remove its own host element — so the consumer writes an
+ * `ng-template` and this directive builds the layer around the stamped view.
+ * It is the shape `ng-template[slCollapsibleContent]` already uses here, and
+ * Angular Material's `matExpansionPanelContent` before it.
+ *
+ * The element it builds is what `packages/core/src/positioner` writes
+ * `position`, `left` and `top` onto, and the one that scales and fades; its
+ * padding is the gap the pointer crosses onto a hoverable tooltip.
+ */
+declare class SlTooltipLayer {
+    private readonly tooltip;
+    private readonly template;
+    private readonly viewContainer;
+    private readonly comment;
+    /**
+     * Angular's server document is not the page. There the layer stays where the
+     * template wrote it, as React's server markup has it, and nothing measures,
+     * stacks or moves it into a portal.
+     */
+    private readonly browser;
+    /** Where the arrow stood in the layer while `arrow` is false. */
+    private arrowPlace;
+    /**
+     * A signal rather than a field, and the reason is a defect the first spec run
+     * found: the effects that place, stack and paint the layer all read it, and
+     * with a plain field none of them re-ran when `build()` filled it in a later
+     * flush. The layer existed and carried no attribute the stylesheet reads.
+     */
+    private readonly layerNode;
+    private view;
+    private portal;
+    private positioner;
+    private dismissable;
+    private releaseBridge;
+    private readonly status;
+    private readonly positioned;
+    private readonly presence;
+    /**
+     * `active` drops the layer after the exit, `lazy` keeps it once it has been
+     * open, `eager` never removes it — which is what `describes="label"` forces,
+     * because an accessible name has to exist before it is read.
+     */
+    readonly mounted: _angular_core.Signal<boolean>;
+    constructor();
+    /** Measures and places the layer again. The imperative action of this part. */
+    reposition(): void;
+    private build;
+    private teardown;
+    /** Rebuilt whenever an option it was created with changes. */
+    private place;
+    /**
+     * The layer joins the single stack only while it is open, so its depth is its
+     * real position among the layers a reader has opened. Escape reaches the
+     * topmost layer alone; the trigger is a branch, so pressing it is not an
+     * outside press and the family closes on it deliberately instead.
+     */
+    private stack;
+    /** Every attribute the stylesheet reads, and the two listeners hoverable needs. */
+    private paint;
+    /**
+     * The arrow is the consumer's element inside the template, so under
+     * `arrow="false"` the layer takes it out — React's arrow renders nothing
+     * then — and puts it back in the same place under `true`.
+     */
+    private showArrow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipLayer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTooltipLayer, "ng-template[slTooltipLayer]", ["slTooltipLayer"], {}, {}, never, never, true, never>;
+}
+/**
+ * The painted surface, and the element the trigger's ARIA relationship names.
+ *
+ * It is the one part written as a component, because a component is what can
+ * carry `styleUrl`: this is where the family's single authored stylesheet
+ * enters an Angular application, exactly as every other family here does it.
+ */
+declare class SlTooltipContent {
+    protected readonly tooltip: SlTooltip;
+    /** Hidden from the reader under `none`, which is a hint shown and not read. */
+    protected readonly hidden: _angular_core.Signal<true | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTooltipContent, "[slTooltipContent]", ["slTooltipContent"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The mark that points at the anchor. The family draws it; the positioner
+ * measures it and says where it goes. It is hidden from assistive technology,
+ * because it is decoration a reader has no use for.
+ */
+declare class SlTooltipArrow {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTooltipArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTooltipArrow, "[slTooltipArrow]", ["slTooltipArrow"], {}, {}, never, never, true, never>;
+}
+
+export { SlTooltip, SlTooltipArrow, SlTooltipContent, SlTooltipGroup, SlTooltipIdFactory, SlTooltipLayer, SlTooltipTrigger, TOOLTIP_DEFAULTS, TOOLTIP_FALLBACK, injectTooltipDefaults, provideSlottedPortalContainer, provideTooltipDefaults };
+export type { TooltipAlign, TooltipChangeRequest, TooltipDefaults, TooltipDescribes, TooltipMount, TooltipOpenOn, TooltipOpenReason, TooltipSide, TooltipSize, TooltipStrategy, TooltipVariant };
+//# sourceMappingURL=slotted-angular-tooltip.d.ts.map

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

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