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

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

@@ -0,0 +1,156 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the set and its items sit at. */
+type AccordionSize = 'sm' | 'md' | 'lg';
+/**
+ * How the set is drawn. `plain` paints nothing, `ruled` puts one hairline per
+ * seam, `framed` wraps the ruled set in one frame, and `separated` gives every
+ * item a card of its own.
+ */
+type AccordionVariant = 'plain' | 'ruled' | 'framed' | 'separated';
+/** The mark each header carries. Handed to every item. */
+type AccordionIndicator = 'chevron' | 'plus-minus' | 'none';
+/** Which side of the words that mark stands on. Handed to every item. */
+type AccordionTogglePlacement = 'end' | 'start';
+/**
+ * The heading level every item's header answers to. `3` is the default, which
+ * is the level the APG's own example uses for a set inside a section.
+ */
+type AccordionHeadingLevel = 'none' | '1' | '2' | '3' | '4' | '5' | '6';
+/** When each panel's content exists. Handed to every item. */
+type AccordionMount = 'active' | 'lazy' | 'eager' | 'until-found';
+/** Why the set of open panels moved. */
+type AccordionSelectionReason = 'pointer' | 'keyboard' | 'select' | 'programmatic';
+interface AccordionDefaults {
+    headingLevel: AccordionHeadingLevel;
+    indicator: AccordionIndicator;
+    loop: boolean;
+    mount: AccordionMount;
+    multiple: boolean;
+    requireOpen: boolean;
+    size: AccordionSize;
+    togglePlacement: AccordionTogglePlacement;
+    truncate: boolean;
+    variant: AccordionVariant;
+}
+declare const ACCORDION_DEFAULTS: InjectionToken<AccordionDefaults>;
+/**
+ * An application decides once how its accordions look and behave, rather than
+ * repeating the same ten inputs on every set in a product. A set that states
+ * any of them itself still wins.
+ */
+declare function provideAccordionDefaults(defaults: Partial<AccordionDefaults>): {
+    provide: InjectionToken<AccordionDefaults>;
+    useFactory: () => AccordionDefaults;
+};
+/** What an accordion renders as here, before it states anything of its own. */
+declare function injectAccordionDefaults(): AccordionDefaults;
+/**
+ * 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 must
+ * match for hydration.
+ */
+declare class SlAccordionIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAccordionIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * The header of every item this set owns, and of no set nested inside it.
+ * `:scope` is what keeps a nested accordion's headers out of the outer one's
+ * arrow ring: root, item, header, trigger is exactly four levels.
+ */
+declare const ACCORDION_TRIGGER_SELECTOR = ":scope > * > [data-part=\"header\"] > [data-part=\"trigger\"]";
+/**
+ * A set of disclosures that share a value.
+ *
+ * **The keyboard is the pattern's, plus four keys that are not.** `Enter`,
+ * `Space`, `Tab` and `Shift + Tab` are the platform's, and every header stays
+ * in the page tab sequence — `w3c/aria-practices#3434` removed the roving
+ * alternative from the pattern, and Base UI deprecated its own `loopFocus` and
+ * `orientation` in the same change. `ArrowDown`, `ArrowUp`, `Home` and `End`
+ * are shipped on top of that sequence, because Radix and Ark both ship them and
+ * readers have learned them; they move focus and write no `tabindex`.
+ *
+ * **`requireOpen` marks the header it holds.** The pattern asks an accordion
+ * that does not permit a panel to be collapsed to write `aria-disabled="true"`
+ * on that header, and the APG's own example is the only surveyed source that
+ * ships it.
+ *
+ * **The items are `collapsible`s, and nothing here selects into them.** The set
+ * hands each one its appearance as a value, which is the rule `checkbox-group`
+ * set for every group family in the library.
+ */
+declare class SlAccordion {
+    /** The set of open values. Two-way, so a template may bind it directly. */
+    readonly value: _angular_core.ModelSignal<readonly string[]>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the set refuses to empty. The one open header then carries
+     * `aria-disabled="true"`, which is what the pattern asks of an accordion that
+     * does not permit its panel to be collapsed.
+     */
+    readonly requireOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<AccordionSize | undefined>;
+    readonly variant: _angular_core.InputSignal<AccordionVariant | undefined>;
+    readonly indicator: _angular_core.InputSignal<AccordionIndicator | undefined>;
+    readonly togglePlacement: _angular_core.InputSignal<AccordionTogglePlacement | undefined>;
+    readonly headingLevel: _angular_core.InputSignal<AccordionHeadingLevel | undefined>;
+    readonly mount: _angular_core.InputSignal<AccordionMount | undefined>;
+    readonly truncate: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * One output for one transition, carrying the reason and the event. `value`
+     * is the two-way half the ecosystem expects; this is the half a boolean
+     * cannot say.
+     */
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    private readonly defaults;
+    private readonly host;
+    private readonly destroyRef;
+    readonly resolvedSize: _angular_core.Signal<AccordionSize>;
+    readonly resolvedVariant: _angular_core.Signal<AccordionVariant>;
+    readonly resolvedIndicator: _angular_core.Signal<AccordionIndicator>;
+    readonly resolvedTogglePlacement: _angular_core.Signal<AccordionTogglePlacement>;
+    readonly resolvedHeadingLevel: _angular_core.Signal<AccordionHeadingLevel>;
+    readonly resolvedMount: _angular_core.Signal<AccordionMount>;
+    readonly resolvedTruncate: _angular_core.Signal<boolean>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedMultiple: _angular_core.Signal<boolean>;
+    readonly resolvedRequireOpen: _angular_core.Signal<boolean>;
+    /** The variant this set hands each of its items, which is not always its own. */
+    readonly itemVariant: _angular_core.Signal<"plain" | "ruled" | "framed">;
+    constructor();
+    private options;
+    /** Whether this value is one of the open ones. */
+    holds(value: string): boolean;
+    /** Whether this value is open and the set refuses to let it close. */
+    isHeld(value: string): boolean;
+    /** Asks the set to open or close one value. */
+    toggle(value: string, reason: AccordionSelectionReason, source?: Event): void;
+    /**
+     * Opens every item that is not disabled. It is Angular Material's `openAll`,
+     * and it is reached through `exportAs` rather than through a handle.
+     */
+    openAll(): void;
+    /** Closes every item, unless `requireOpen` holds the last one. */
+    closeAll(): void;
+    /**
+     * The items, read from the DOM rather than from a registry. It is the one
+     * order that is never stale, and it is how `tabs` reads its own collection.
+     */
+    private items;
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAccordion, "[slAccordion]", ["slAccordion"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "requireOpen": { "alias": "requireOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "togglePlacement": { "alias": "togglePlacement"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChangeRequest": "valueChangeRequest"; }, never, ["*"], true, never>;
+}
+
+export { ACCORDION_DEFAULTS, ACCORDION_TRIGGER_SELECTOR, SlAccordion, SlAccordionIdFactory, injectAccordionDefaults, provideAccordionDefaults };
+export type { AccordionDefaults, AccordionHeadingLevel, AccordionIndicator, AccordionMount, AccordionSelectionReason, AccordionSize, AccordionTogglePlacement, AccordionVariant };
+//# sourceMappingURL=slotted-angular-accordion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-accordion.d.ts","sources":["../../accordion/src/accordion-defaults.ts","../../accordion/src/accordion.ts"],"mappings":";;;;AAEA;AACM,KAAM,aAAa;AAEzB;;;;AAIG;AACG,KAAM,gBAAgB;AAE5B;AACM,KAAM,kBAAkB;AAE9B;KACY,wBAAwB;AAEpC;;;AAGG;KACS,qBAAqB;AAEjC;AACM,KAAM,cAAc;AAE1B;AACM,KAAM,wBAAwB;UAEnB,iBAAiB;kBAClB,qBAAqB;eACxB,kBAAkB;;WAEtB,cAAc;;;UAGf,aAAa;qBACF,wBAAwB;;aAEhC,gBAAgB;AAC1B;AAeD,cAAa,kBAAkB,EAAA,cAAA,CAAA,iBAAA;AAK/B;;;;AAIG;AACH,iBAAgB,wBAAwB,WAAW,OAAO,CAAC,iBAAiB;;sBAGxD,iBAAiB;AAEpC;AAED;AACA,iBAAgB,uBAAuB,IAAI,iBAAiB;AAI5D;;;;;AAKG;AACH,cACa,oBAAoB;;;oDAApB,oBAAoB;;AAOhC;;ACnDD;;;;AAIG;AACH,cAAa,0BAA0B;AAWvC;;;;;;;;;;;;;;;;;;;AAmBG;AACH,cAgBa,WAAW;;oBAER,aAAA,CAAA,WAAA;uBACG,aAAA,CAAA,wBAAA;AACjB;;;;AAIG;0BACiB,aAAA,CAAA,wBAAA;uBACH,aAAA,CAAA,wBAAA;mBACJ,aAAA,CAAA,WAAA,CAAA,aAAA;sBACG,aAAA,CAAA,WAAA,CAAA,gBAAA;wBACE,aAAA,CAAA,WAAA,CAAA,kBAAA;8BACM,aAAA,CAAA,WAAA,CAAA,wBAAA;2BACH,aAAA,CAAA,WAAA,CAAA,qBAAA;oBACP,aAAA,CAAA,WAAA,CAAA,cAAA;uBACG,aAAA,CAAA,wBAAA;mBAGJ,aAAA,CAAA,wBAAA;AAIb;;;;AAIG;iCACwB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAE3B;AACA;AACA;2BAEqB,aAAA,CAAA,MAAA,CAAA,aAAA;8BACG,aAAA,CAAA,MAAA,CAAA,gBAAA;gCACE,aAAA,CAAA,MAAA,CAAA,kBAAA;sCACM,aAAA,CAAA,MAAA,CAAA,wBAAA;mCAGH,aAAA,CAAA,MAAA,CAAA,qBAAA;4BACP,aAAA,CAAA,MAAA,CAAA,cAAA;+BACG,aAAA,CAAA,MAAA;2BACJ,aAAA,CAAA,MAAA;+BACI,aAAA,CAAA,MAAA;kCACG,aAAA,CAAA,MAAA;;0BAGR,aAAA,CAAA,MAAA;;AAuBpB;;AAKA;;AAKA;;AAKA,kCAA8B,wBAAwB,WAAW,KAAK;AAMtE;;;AAGG;;;;AAkBH;;;AAGG;AACH;AAIA;oDA1HW,WAAW;sDAAX,WAAW;AA4IvB;;","names":[]}

package/types/slotted-angular-action-bar.d.ts

@@ -0,0 +1,291 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { MenuAlign, MenuSide, MenuSize } from '@slotted/angular/menu';
+
+/** Whether the bar paints a ground and a rule of its own. */
+type ActionBarVariant = 'plain' | 'raised';
+/** The step the bar's own inset, gap and separator sit at. */
+type ActionBarSize = 'sm' | 'md' | 'lg';
+/** Where the run of actions sits in the room left after the status. */
+type ActionBarAlign = 'end' | 'start' | 'center';
+/**
+ * Where an action stands in the order of giving way.
+ *
+ * The five are adapted from `sap.m.OverflowToolbarPriority`, and they exist here
+ * and not in `toolbar` because the two bars read in opposite directions. In a
+ * bar of tools the first control is the most used, so giving way from the end
+ * gives up the least used one. In a bar of actions the action that confirms is
+ * at the **end** of the line, so giving way from the end would give up Save
+ * first.
+ *
+ * - `pinned` never gives way.
+ * - `high` gives way after `low` and `hide`, into the surface.
+ * - `low` is the first rank to reach the surface, and the default for an action
+ *   that declares a counterpart.
+ * - `hide` gives way before every other rank and is **not** offered in the
+ *   surface: a control that is not worth a row in a menu.
+ * - `always` is never drawn in the bar; its counterpart is in the surface from
+ *   the start.
+ */
+type ActionBarPriority = 'pinned' | 'high' | 'low' | 'hide' | 'always';
+interface ActionBarDefaults {
+    align: ActionBarAlign;
+    size: ActionBarSize;
+    sticky: boolean;
+    variant: ActionBarVariant;
+}
+declare const ACTION_BAR_DEFAULTS: InjectionToken<ActionBarDefaults>;
+/**
+ * An application decides once how its action bars are drawn — a product whose
+ * bars are all raised, compact and stuck to the bottom of the page says so in
+ * one place rather than on every bar. A bar that states any of them itself
+ * still wins.
+ */
+declare function provideActionBarDefaults(defaults: Partial<ActionBarDefaults>): {
+    provide: InjectionToken<ActionBarDefaults>;
+    useFactory: () => ActionBarDefaults;
+};
+/** What a bar renders as here, before it states anything of its own. */
+declare function injectActionBarDefaults(): ActionBarDefaults;
+
+/**
+ * The accessible name of the control that holds what did not fit. A string is
+ * used verbatim; a function is given the number of actions behind the control,
+ * because three dots say nothing about how much is behind them.
+ */
+type ActionBarOverflowLabel = string | ((hidden: number) => string);
+/** One action the surface holds, in the order the bar holds it. */
+interface ActionBarSurfaceUnit {
+    readonly id: string;
+    readonly separatorBefore: boolean;
+}
+/** The attribute that says an action has somewhere to go. */
+declare const ACTION_BAR_UNIT_ATTRIBUTE = "data-unit";
+/** The attribute the measurement reads a rank from. */
+declare const ACTION_BAR_PRIORITY_ATTRIBUTE = "data-priority";
+/**
+ * The custom property the stacking query raises, read back by the measurement.
+ *
+ * The breakpoint is literal because `@container (width < var(--x))` is invalid,
+ * and it is written once — in the stylesheet. The binding asks CSS what it
+ * decided rather than comparing widths of its own, so the layout and the
+ * measurement cannot disagree about where the bar becomes a column.
+ */
+declare const ACTION_BAR_STACK_PROPERTY = "--_stacked";
+/**
+ * Where each rank stands in the order of giving way: the lowest goes first, and
+ * position decides inside one rank.
+ */
+declare const ACTION_BAR_RANK: Readonly<Record<ActionBarPriority, number>>;
+/**
+ * The actions that finish a task on a page or in a panel.
+ *
+ * **It is not a composite.** `Tab` reaches every action, in the order the author
+ * wrote them, and the arrows are not bound. The controls here are the page's own
+ * form actions, and a reader walking a form expects to arrive at Cancel and then
+ * at Save; roving focus would make the whole bar one tab stop and put Save
+ * behind an arrow key that announces nothing. A strip of ten icon buttons is a
+ * `toolbar`, and that family binds the arrows against the APG.
+ *
+ * **What gives way is decided by rank, not by position**, which is the whole of
+ * why this family stands beside `toolbar` rather than configuring it.
+ *
+ * **The action that confirms does not move.** The run carries an `auto` margin
+ * against the bar's end edge, so a message appearing in the status, a button
+ * going busy and a permission filter removing a control all move what is
+ * *before* the last action and never the last action itself.
+ */
+declare class SlActionBar {
+    readonly variant: _angular_core.InputSignal<ActionBarVariant | undefined>;
+    readonly size: _angular_core.InputSignal<ActionBarSize | undefined>;
+    readonly align: _angular_core.InputSignal<ActionBarAlign | undefined>;
+    readonly sticky: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Whether the bar belongs on screen at all. A bulk bar exists while there is a
+     * selection and a contextual save bar while there are unsaved changes.
+     *
+     * It is an input rather than a two-way value: the bar never asks to appear or
+     * to leave, so there is nothing to cancel.
+     */
+    readonly present: _angular_core.InputSignalWithTransform<boolean, string | boolean | undefined>;
+    /**
+     * Reports how many actions gave way, once per change. The collapsed set is a
+     * measurement rather than a value, so there is no two-way binding over it.
+     */
+    readonly overflowChange: _angular_core.OutputEmitterRef<number>;
+    private readonly defaults;
+    private readonly element;
+    /**
+     * A consumer who has ten icon-only actions and wants the composite may write
+     * `role="toolbar"` themselves, and what they wrote survives the host binding.
+     * The arrows are still not bound, so that consumer wants `toolbar`.
+     */
+    private readonly statedRole;
+    private readonly counterparts;
+    private readonly trigger;
+    private readonly actions;
+    private readonly stacked;
+    private readonly ready;
+    private collapse;
+    /** What the surface holds: the collapsed actions and every `always` one. */
+    readonly surfaceUnits: _angular_core.WritableSignal<readonly ActionBarSurfaceUnit[]>;
+    readonly resolvedVariant: _angular_core.Signal<ActionBarVariant>;
+    readonly resolvedSize: _angular_core.Signal<ActionBarSize>;
+    readonly resolvedAlign: _angular_core.Signal<ActionBarAlign>;
+    readonly resolvedSticky: _angular_core.Signal<boolean>;
+    protected readonly role: _angular_core.Signal<string>;
+    private readonly status;
+    protected readonly mounted: _angular_core.Signal<boolean>;
+    protected readonly presenceAttribute: _angular_core.Signal<"entering" | "exiting" | null>;
+    protected readonly collapsedCount: _angular_core.Signal<string | null>;
+    /** Records what an action 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;
+    /** The run, which is the box the collapse measures rather than the root. */
+    registerActions(element: HTMLElement | null): void;
+    constructor();
+    /** Measures again, after the consumer changed something the DOM cannot report. */
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlActionBar, "[slActionBar]", ["slActionBar"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "present": { "alias": "present"; "required": false; "isSignal": true; }; }, { "overflowChange": "overflowChange"; }, never, ["*"], true, never>;
+}
+/**
+ * The sentence at the start of the bar: a dirty-state marker, a timestamp, the
+ * count of what is selected and the control that selects the rest.
+ *
+ * It is a slot rather than a component: the library already has
+ * `inline-message`, `status-indicator` and `badge`, and `table` already owns the
+ * selection and its count.
+ */
+declare class SlActionBarStatus {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBarStatus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlActionBarStatus, "[slActionBarStatus]", ["slActionBarStatus"], {}, {}, never, never, true, never>;
+}
+/**
+ * The run of actions, and the box the collapse measures.
+ *
+ * It is the run rather than the root, because the root is the query container
+ * and a container is a container for its descendants and not for itself — so the
+ * rule that turns the run into a column has to reach a descendant.
+ */
+declare class SlActionBarActions {
+    private readonly bar;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBarActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlActionBarActions, "[slActionBarActions]", ["slActionBarActions"], {}, {}, never, never, true, never>;
+}
+/**
+ * One action the bar may give up, its rank, and what it becomes when it goes.
+ *
+ * The rank and the counterpart are one fact seen from two sides. A control with
+ * nothing to become in the surface is pinned — it has nowhere to go, which is
+ * why the action that confirms stays visible — and a rank that needs somewhere
+ * to go and has nowhere behaves as pinned too, so a consumer error leaves the
+ * control on the bar rather than hiding it silently.
+ */
+declare class SlActionBarAction {
+    /**
+     * What the action becomes in the surface when the bar has no room for it.
+     *
+     * It is deliberately not called `overflow`: that word names what a container
+     * does with more content than it has room for, and one term with two meanings
+     * is the ambiguity the contract exists to prevent.
+     */
+    readonly counterpart: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    /**
+     * Where this action stands in the order of giving way.
+     *
+     * It is the selector's own value, so the terse form reads as the sentence it
+     * is — `slActionBarAction="high"`. A bare `slActionBarAction` hands the
+     * directive an empty string, which is the attribute being present rather than
+     * a rank, and the transform reads it as unstated.
+     */
+    readonly priority: _angular_core.InputSignalWithTransform<ActionBarPriority | undefined, "" | ActionBarPriority | undefined>;
+    private readonly bar;
+    private readonly identity;
+    protected readonly unitId: _angular_core.Signal<string | null>;
+    readonly resolvedPriority: _angular_core.Signal<ActionBarPriority>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBarAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlActionBarAction, "[slActionBarAction]", ["slActionBarAction"], { "counterpart": { "alias": "slActionBarActionCounterpart"; "required": false; "isSignal": true; }; "priority": { "alias": "slActionBarAction"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A hairline between two runs of actions.
+ *
+ * It is the answer to the one line of `docs/component-features.md` §5 that names
+ * no mechanism: a destructive action does not sit flush against a frequent one.
+ * It is a part of this family rather than a `divider` because its geometry
+ * belongs to the bar.
+ */
+declare class SlActionBarSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBarSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlActionBarSeparator, "[slActionBarSeparator]", ["slActionBarSeparator"], {}, {}, 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 actions
+ * give way, **by rank**, and the counterparts they declared are rendered here in
+ * the order the bar holds them — with a separator wherever one of the bar's own
+ * rules sits between two of them.
+ *
+ * The surface also holds every action ranked `always`, which was never drawn in
+ * the bar at all. A reader opening the menu sees one list, so the two sources
+ * are read together and in the bar's own order.
+ *
+ * The counterpart is an `ng-template` rendered through `NgTemplateOutlet` only
+ * while its action is in the surface, 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` would look for the `SlMenu` above the
+ * bar and find none. The outlet is therefore given an injector that provides the
+ * surface this component draws.
+ *
+ * The host is `display: contents`, so the `button` below is a child of the run
+ * itself: the part that carries the geometry has to be the box the bar lays out.
+ *
+ * **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 SlActionBarOverflow {
+    /** 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<ActionBarOverflowLabel | undefined>;
+    protected readonly bar: SlActionBar;
+    /** 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 the surface holds nothing
+     * and the outlet renders nothing.
+     */
+    protected readonly surfaceInjector: _angular_core.Signal<_angular_core.DestroyableInjector | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlActionBarOverflow, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlActionBarOverflow, "sl-action-bar-overflow", ["slActionBarOverflow"], { "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 { ACTION_BAR_DEFAULTS, ACTION_BAR_PRIORITY_ATTRIBUTE, ACTION_BAR_RANK, ACTION_BAR_STACK_PROPERTY, ACTION_BAR_UNIT_ATTRIBUTE, SlActionBar, SlActionBarAction, SlActionBarActions, SlActionBarOverflow, SlActionBarSeparator, SlActionBarStatus, injectActionBarDefaults, provideActionBarDefaults };
+export type { ActionBarAlign, ActionBarDefaults, ActionBarOverflowLabel, ActionBarPriority, ActionBarSize, ActionBarSurfaceUnit, ActionBarVariant };
+//# sourceMappingURL=slotted-angular-action-bar.d.ts.map

package/types/slotted-angular-action-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-action-bar.d.ts","sources":["../../action-bar/src/action-bar-defaults.ts","../../action-bar/src/action-bar.ts","../../action-bar/src/action-bar-overflow.ts"],"mappings":";;;;AAEA;KACY,gBAAgB;AAE5B;AACM,KAAM,aAAa;AAEzB;AACM,KAAM,cAAc;AAE1B;;;;;;;;;;;;;;;;;;AAkBG;AACG,KAAM,iBAAiB;UAEZ,iBAAiB;WACzB,cAAc;UACf,aAAa;;aAEV,gBAAgB;AAC1B;AASD,cAAa,mBAAmB,EAAA,cAAA,CAAA,iBAAA;AAKhC;;;;;AAKG;AACH,iBAAgB,wBAAwB,WAAW,OAAO,CAAC,iBAAiB;;sBAGxD,iBAAiB;AAEpC;AAED;AACA,iBAAgB,uBAAuB,IAAI,iBAAiB;;ACxB5D;;;;AAIG;AACG,KAAM,sBAAsB;AAElC;UACiB,oBAAoB;AACnC;AACA;AACD;AAED;AACA,cAAa,yBAAyB;AAEtC;AACA,cAAa,6BAA6B;AAE1C;;;;;;;AAOG;AACH,cAAa,yBAAyB;AAEtC;;;AAGG;AACH,cAAa,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB;AAyE/D;;;;;;;;;;;;;;;;;AAiBG;AACH,cAsBa,WAAW;sBACN,aAAA,CAAA,WAAA,CAAA,gBAAA;mBACH,aAAA,CAAA,WAAA,CAAA,aAAA;oBACC,aAAA,CAAA,WAAA,CAAA,cAAA;qBACC,aAAA,CAAA,wBAAA;AAGf;;;;;;AAMG;sBACa,aAAA,CAAA,wBAAA;AAIhB;;;AAGG;6BACoB,aAAA,CAAA,gBAAA;AAEvB;AACA;AAEA;;;;AAIG;AACH;AAEA;AACA;AACA;AACA;AACA;;;2BAIqB,aAAA,CAAA,cAAA,UAAA,oBAAA;8BAEG,aAAA,CAAA,MAAA,CAAA,gBAAA;2BACH,aAAA,CAAA,MAAA,CAAA,aAAA;4BACC,aAAA,CAAA,MAAA,CAAA,cAAA;6BACC,aAAA,CAAA,MAAA;AAEvB,6BAAuB,aAAA,CAAA,MAAA;AAEvB;AACA,gCAA0B,aAAA,CAAA,MAAA;AAC1B,0CAAoC,aAAA,CAAA,MAAA;AAKpC,uCAAiC,aAAA,CAAA,MAAA;;uCAKE,WAAW;;6BAYxB,WAAA;;AAKtB,6BAAyB,WAAW;;AAKpC,6BAAyB,WAAW;;;;oDArFzB,WAAW;sDAAX,WAAW;AAqNvB;AAED;;;;;;;AAOG;AACH,cAMa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;AAEjC;;;;;;AAMG;AACH,cAMa,kBAAkB;AAC7B;;oDADW,kBAAkB;sDAAlB,kBAAkB;AAQ9B;AAED;;;;;;;;AAQG;AACH,cAWa,iBAAiB;AAC5B;;;;;;AAMG;0BACiB,aAAA,CAAA,WAAA,CAAA,WAAA;AAIpB;;;;;;;AAOG;uBACc,aAAA,CAAA,wBAAA,CAAA,iBAAA,mBAAA,iBAAA;AAKjB;AACA;AAEA,+BAAyB,aAAA,CAAA,MAAA;+BAIA,aAAA,CAAA,MAAA,CAAA,iBAAA;;oDAhCd,iBAAiB;sDAAjB,iBAAiB;AAmD7B;AAID;;;;;;;AAOG;AACH,cAMa,oBAAoB;oDAApB,oBAAoB;sDAApB,oBAAoB;AAAG;;AC5fpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH,cA4Ba,mBAAmB;;oBAEhB,aAAA,CAAA,WAAA,CAAA,SAAA;mBACD,aAAA,CAAA,WAAA,CAAA,QAAA;;mBAEA,aAAA,CAAA,WAAA,CAAA,QAAA;AACb;;;AAGG;oBACW,aAAA,CAAA,WAAA,CAAA,sBAAA;AAEd,4BAAsB,WAAA;;AAGtB;AAEA,6BAAuB,aAAA,CAAA,MAAA;AASvB;AACA;AACA;AAEA;;;AAGG;AACH,wCAAkC,aAAA,CAAA,MAAA,CAAA,aAAA,CAAA,mBAAA;;oDAlCvB,mBAAmB;sDAAnB,mBAAmB;AAiE/B;;","names":[]}