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

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

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

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

@@ -0,0 +1,340 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, TemplateRef } from '@angular/core';
+import { OverflowState } from '@slotted/core/overflow';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** Whether moving focus to a tab also selects it. */
+type TabsActivation = 'automatic' | 'manual';
+/** Which way the list runs. A horizontal list scrolls; a vertical one stacks. */
+type TabsOrientation = 'horizontal' | 'vertical';
+/** The type step the list and its tabs sit at. */
+type TabsSize = 'sm' | 'md' | 'lg';
+/**
+ * How the list is drawn. `line` is a row of labels over a hairline; `contained`
+ * is a sunken track holding a surface per tab. Both paint the same marker,
+ * which is what survives the `high-contrast` scheme.
+ */
+type TabsVariant = 'line' | 'contained';
+/**
+ * Whether the list draws the line its tabs stand on. `none` is for a list that
+ * sits on a line the page already drew — a card header's edge, a table's own
+ * rule — where two hairlines a pixel apart read as one smudge.
+ */
+type TabsTrack = 'line' | 'none';
+/** Whether each tab is as wide as its label or takes an equal share of the line. */
+type TabsFit = 'auto' | 'equal';
+/**
+ * When a panel exists. The names are Cloudscape's, which are the clearest three
+ * words in the field for the same three behaviours.
+ */
+type TabsMount = 'active' | 'lazy' | 'eager';
+/** Which way the selection travelled, from the two indices. */
+type TabsActivationDirection = 'forward' | 'backward' | 'none';
+interface TabsDefaults {
+    activation: TabsActivation;
+    fit: TabsFit;
+    track: TabsTrack;
+    loop: boolean;
+    mount: TabsMount;
+    orientation: TabsOrientation;
+    size: TabsSize;
+    variant: TabsVariant;
+}
+declare const TABS_DEFAULTS: InjectionToken<TabsDefaults>;
+/**
+ * An application decides once how its tabs look and behave, rather than
+ * repeating the same seven inputs on every family in a product. A family that
+ * states any of them itself still wins.
+ */
+declare function provideTabsDefaults(defaults: Partial<TabsDefaults>): {
+    provide: InjectionToken<TabsDefaults>;
+    useFactory: () => TabsDefaults;
+};
+/** What a tabs family renders as here, before it states anything of its own. */
+declare function injectTabsDefaults(): TabsDefaults;
+/**
+ * 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 SlTabsIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabsIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** Every tab in the list, in the order the DOM holds them. */
+declare const TAB_SELECTOR = "[data-part=\"tab\"]";
+/** Why the selection moved. */
+type TabsSelectionReason = 'pointer' | 'keyboard' | 'remove' | 'programmatic';
+/** Why a tab was dismissed. */
+type TabsDismissReason = 'pointer' | 'keyboard';
+/**
+ * The request a dismissal carries. It holds no value pair, because nothing is
+ * replacing anything: the value being dismissed is `value`, and the shape is
+ * `tag`'s, which set the convention for a removal in this library.
+ */
+interface TabsDismissRequest {
+    readonly value: string;
+    readonly reason: TabsDismissReason;
+    readonly source: Event;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+/**
+ * An identifier from a value, injectively.
+ *
+ * A value is the consumer's own string and may hold a space, which no
+ * identifier may. Escaping the characters an identifier refuses — rather than
+ * replacing them — is what keeps two values from wiring one panel.
+ */
+declare function escapeTabValue(value: string): string;
+/**
+ * One view out of several, and the panels under it.
+ *
+ * **The keyboard is the APG's, and it is implemented once.** The list is a
+ * roving tab stop from `@slotted/core/focus`: `Tab` enters on the selected tab,
+ * the arrows of the flow axis move and wrap, `Home` and `End` reach the ends,
+ * and the cross axis is left alone so the page still scrolls with focus inside
+ * a horizontal list. `Delete` dismisses a dismissible tab, and focus lands
+ * where the pattern says.
+ *
+ * **The marker moves without a measurement.** The root records which way the
+ * selection travelled and the stylesheet turns that into a transform origin, so
+ * the family is right in a server response and during the first paint.
+ *
+ * **The paging controls belong to the root**, because the root owns the observer
+ * that knows whether they are needed. They are out of the tab sequence and out
+ * of the accessibility tree: the arrows already reach every tab and bring it
+ * into view.
+ */
+declare class SlTabs implements OnInit {
+    /** Present means the consumer owns the selection. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** The value an uncontrolled family starts from, read once. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    readonly activation: _angular_core.InputSignal<TabsActivation | undefined>;
+    readonly orientation: _angular_core.InputSignal<TabsOrientation | undefined>;
+    readonly size: _angular_core.InputSignal<TabsSize | undefined>;
+    readonly variant: _angular_core.InputSignal<TabsVariant | undefined>;
+    /** `none` draws no line at all, for a list standing on one the page drew. */
+    readonly track: _angular_core.InputSignal<TabsTrack | undefined>;
+    readonly fit: _angular_core.InputSignal<TabsFit | undefined>;
+    readonly mount: _angular_core.InputSignal<TabsMount | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Reaches every tab as the native attribute, which is also what makes the
+        browser skip it with the arrow keys. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<string | undefined>>;
+    /**
+     * Asked before a tab is dismissed. The family removes nothing: the consumer
+     * owns the collection, and a component that removed itself would render
+     * nothing while the consumer's array still held the item.
+     */
+    readonly tabDismiss: _angular_core.OutputEmitterRef<TabsDismissRequest>;
+    private readonly defaults;
+    private readonly baseId;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly own;
+    private readonly listElement;
+    private readonly seen;
+    private roving;
+    private affordance;
+    protected readonly direction: _angular_core.WritableSignal<TabsActivationDirection>;
+    protected readonly overflow: _angular_core.WritableSignal<OverflowState>;
+    readonly selection: _angular_core.Signal<string | undefined>;
+    readonly resolvedActivation: _angular_core.Signal<TabsActivation>;
+    readonly resolvedOrientation: _angular_core.Signal<TabsOrientation>;
+    readonly resolvedSize: _angular_core.Signal<TabsSize>;
+    readonly resolvedVariant: _angular_core.Signal<TabsVariant>;
+    readonly resolvedTrack: _angular_core.Signal<TabsTrack>;
+    readonly resolvedFit: _angular_core.Signal<TabsFit>;
+    readonly resolvedMount: _angular_core.Signal<TabsMount>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    protected readonly paging: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    /** The identifiers a tab and its panel are wired together with. */
+    identify(value: string): {
+        panelId: string;
+        tabId: string;
+    };
+    /** Whether this value is the selected one. Read by every tab and panel. */
+    holds(value: string): boolean;
+    /** Whether this value has ever been selected, which is what `lazy` reads. */
+    hasSeen(value: string): boolean;
+    /**
+     * The list hands the root its element. The root owns the roving tab stop, the
+     * removal focus and the overflow observer — all three are about that element,
+     * and the root is what holds the value they act on.
+     */
+    attachList(element: HTMLElement): void;
+    private tabElements;
+    private indexOf;
+    /**
+     * Asks the family to select one value. The direction is set in the same turn,
+     * so the marker's origin and the selection reach the DOM in one paint.
+     */
+    select(next: string, reason: TabsSelectionReason, source?: Event): void;
+    /**
+     * The neighbour a dismissal leaves the selection to: the tab that followed
+     * the dismissed one, or the one before it when the dismissed tab was last.
+     * It is the APG's own focus rule for `Delete`, applied to the value.
+     */
+    private neighbourOf;
+    dismiss(value: string, reason: TabsDismissReason, source: Event): void;
+    /** Puts the tab stop on the selected tab and brings it into view. */
+    syncSelection(): void;
+    private revealSelected;
+    protected page(direction: -1 | 1): void;
+    private observe;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTabs, "[slTabs]", ["slTabs"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "activation": { "alias": "activation"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "track": { "alias": "track"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "tabDismiss": "tabDismiss"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The list of tabs, and the one tab stop the family holds.
+ *
+ * It hands its element to the root, which owns the roving tab stop, the removal
+ * focus and the overflow observer. `tabindex="-1"` is the last resort of the
+ * removal focus: a list emptied by its final dismissal keeps focus rather than
+ * returning it to the top of the page.
+ *
+ * Its accessible name is the consumer's own `aria-label` or `aria-labelledby`:
+ * only the page knows what the set of views is for.
+ */
+declare class SlTabList {
+    private readonly tabs;
+    protected readonly ariaOrientation: _angular_core.Signal<"vertical" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTabList, "[slTabList]", ["slTabList"], {}, {}, never, never, true, never>;
+}
+/**
+ * What precedes the label inside a tab, such as an icon. It stands beside the
+ * words rather than inside them, so the tab's gap spaces it and only the words
+ * are clipped under `fit="equal"`; the part sizes an icon to the tab's icon step.
+ */
+declare class SlTabStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTabStart, "[slTabStart]", ["slTabStart"], {}, {}, never, never, true, never>;
+}
+/** What follows the label inside a tab, such as a count. */
+declare class SlTabEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTabEnd, "[slTabEnd]", ["slTabEnd"], {}, {}, never, never, true, never>;
+}
+/**
+ * One tab, in the box that holds it.
+ *
+ * The host is that box, and it is presentational for two reasons a `button`
+ * cannot answer: a `button` may not contain a `button`, so a dismissible tab
+ * needs somewhere to put its second control, and the marker has to span the
+ * pair rather than only the label.
+ *
+ * `href` makes the control an anchor, and a click carrying a modifier key is
+ * left to the browser so a deep link still opens in a new browser tab.
+ */
+declare class SlTab {
+    /** What this tab selects. It is what the family's value holds. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Unstated rather than `false`, so the tab defers to the family. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Whether this tab carries a control that closes it. */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The accessible name of that control. Required whenever it is drawn. */
+    readonly dismissLabel: _angular_core.InputSignal<string | undefined>;
+    /** Makes the control an anchor, for a view a router can deep-link to. */
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The id of the element this tab controls, when it is not a panel of this
+     * family: a strip over one region whose content the value filters — a
+     * feed, a table — names that region here, and `aria-controls` says so.
+     */
+    readonly controls: _angular_core.InputSignal<string | undefined>;
+    /** The family this tab belongs to. Public, because a template may read it. */
+    readonly tabs: SlTabs;
+    readonly selected: _angular_core.Signal<boolean>;
+    /**
+     * A family out of action takes every tab with it. The tab's own input can
+     * only add to that, never subtract: a consumer that writes `[disabled]="false"`
+     * on a tab inside a disabled family is saying nothing about that family, and a
+     * template that binds an expression writes `false` where it means "not this
+     * one" — which is how every tab stayed operable while the family reported
+     * itself disabled.
+     */
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    protected readonly tabId: _angular_core.Signal<string>;
+    protected readonly panelId: _angular_core.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    /**
+     * `Delete` closes the tab, which is the key the APG names for it. A held key
+     * repeats, and a repeat would close the tab focus has just landed on.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onDismiss(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTab, "[slTab]", ["slTab"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "dismissLabel": { "alias": "dismissLabel"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; }, {}, never, ["[slTabStart]", "*", "[slTabEnd]"], true, never>;
+}
+/**
+ * The content of a panel, as a template the panel instantiates.
+ *
+ * Projected markup is built by the consumer's own view whether a panel shows it
+ * or not: a component inside a closed panel is constructed, change-detected and
+ * keeps its state, and only its DOM is detached. A template is what `mount` can
+ * act on. Under `active` it is instantiated on selection and destroyed after,
+ * under `lazy` it is instantiated on first selection and kept, under `eager` it
+ * is instantiated up front. It is the shape of Angular Material's `matTabContent`.
+ *
+ * It must be a direct child of the panel, so a panel never takes the template of
+ * a family nested inside it.
+ */
+declare class SlTabPanelContent {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabPanelContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTabPanelContent, "ng-template[slTabPanelContent]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The content of one tab.
+ *
+ * It is in the page's tab sequence, which is where `Tab` from the list goes, and
+ * it is hidden with the attribute rather than with a class: a screen reader,
+ * find-in-page and `:target` all already understand `hidden`.
+ *
+ * The panel itself always exists, so every tab's `aria-controls` names an
+ * element. Whether its content is in the DOM is what `mount` decides. Content
+ * written inside `<ng-template slTabPanelContent>` is also only built when
+ * `mount` says so; projected markup is built by the consumer's view regardless.
+ */
+declare class SlTabPanel {
+    /** The tab this panel belongs to. */
+    readonly value: _angular_core.InputSignal<string>;
+    private readonly tabs;
+    /** The deferred content, when the consumer wrote one. */
+    protected readonly content: _angular_core.Signal<SlTabPanelContent | undefined>;
+    readonly selected: _angular_core.Signal<boolean>;
+    protected readonly panelId: _angular_core.Signal<string>;
+    protected readonly tabId: _angular_core.Signal<string>;
+    protected readonly present: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTabPanel, "[slTabPanel]", ["slTabPanel"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, ["content"], ["*"], true, never>;
+}
+/**
+ * The slot beside the list, on the same row.
+ *
+ * What belongs in it is a `toolbar`: one tab stop for however many actions the
+ * page puts there, which is what keeps the distance between the tab list and the
+ * panel to the two stops the pattern asks for.
+ */
+declare class SlTabActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTabActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTabActions, "[slTabActions]", ["slTabActions"], {}, {}, never, never, true, never>;
+}
+
+export { SlTab, SlTabActions, SlTabEnd, SlTabList, SlTabPanel, SlTabPanelContent, SlTabStart, SlTabs, SlTabsIdFactory, TABS_DEFAULTS, TAB_SELECTOR, escapeTabValue, injectTabsDefaults, provideTabsDefaults };
+export type { TabsActivation, TabsActivationDirection, TabsDefaults, TabsDismissReason, TabsDismissRequest, TabsFit, TabsMount, TabsOrientation, TabsSelectionReason, TabsSize, TabsTrack, TabsVariant };
+//# sourceMappingURL=slotted-angular-tabs.d.ts.map

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

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

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

@@ -0,0 +1,279 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TagMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+import { ChangeReason, ChangeRequest } from '@slotted/core/state';
+
+/** Which of the five semantic colours the tag speaks in. */
+type TagTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/** How that colour is painted. `soft` is the tinted chip a tag usually is. */
+type TagVariant = 'solid' | 'soft' | 'outline';
+type TagSize = 'sm' | 'md' | 'lg';
+type TagShape = 'pill' | 'square';
+type TagOrientation = 'horizontal' | 'vertical';
+interface TagDefaults {
+    shape: TagShape;
+    size: TagSize;
+    tone: TagTone;
+    variant: TagVariant;
+}
+declare const TAG_DEFAULTS: InjectionToken<TagDefaults>;
+/**
+ * An application decides once how its tags are painted and how large they are,
+ * rather than repeating four inputs on every chip in a filter bar. A tag that
+ * states any of them itself still wins: an explicit input is never overridden
+ * by the token. The remove control's word comes from the language in force
+ * (`provideSlotted`).
+ */
+declare function provideTagDefaults(defaults: Partial<TagDefaults>): {
+    provide: InjectionToken<TagDefaults>;
+    useFactory: () => TagDefaults;
+};
+/** What a tag renders as here, before it states anything of its own. */
+declare function injectTagDefaults(): TagDefaults;
+
+/**
+ * How the removal was asked for. `remove` is the control at the end of the
+ * chip; `keyboard` is `Backspace` or `Delete` pressed on it.
+ */
+type TagRemoveReason = Extract<ChangeReason, 'remove' | 'keyboard'>;
+/**
+ * A request to be taken out of the collection that holds the tag, and never a
+ * value: the tag does not own whether it exists. Refusing it is what stops the
+ * group from moving focus, which is the one thing the family would otherwise
+ * commit on its own.
+ */
+interface TagRemoveRequest {
+    readonly reason: TagRemoveReason;
+    readonly source: Event;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+/**
+ * The chip box: an entity, a filter or a compact value. It is not metadata —
+ * that is `badge`, and the two share this tone and this type scale on purpose.
+ *
+ * **The root is never the interactive element.** A `button` cannot contain a
+ * `button` and an `a` cannot contain either, so a chip that both acts and
+ * removes has to put its two controls side by side. The chip is written on the
+ * consumer's own `span`; what the chip *is* is decided by the element under
+ * `slTagBody`: a `span` does nothing, a `button` runs a command, an `a`
+ * navigates, and `slTagToggle` holds a selection. The element is the member,
+ * which is what keeps `routerLink`, `type` and every native attribute on the
+ * element that owns them.
+ */
+declare class SlTag {
+    /** Defaults to the provider, then to `secondary`. */
+    readonly tone: _angular_core.InputSignal<TagTone | undefined>;
+    /** Defaults to the provider, then to `soft`. */
+    readonly variant: _angular_core.InputSignal<TagVariant | undefined>;
+    /** Defaults to the provider, then to `md`. */
+    readonly size: _angular_core.InputSignal<TagSize | undefined>;
+    /** Defaults to the provider, then to `pill`. */
+    readonly shape: _angular_core.InputSignal<TagShape | undefined>;
+    /** Refuses every interaction the tag offers, including its removal. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the chip can be removed at all. React reads the same fact from
+     * whether a handler was passed; Angular cannot see whether an output was
+     * subscribed, so the opt-in is stated — the asymmetry `button` recorded for
+     * its own toggle.
+     */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Refuses the removal while the rest of the tag stays operable. */
+    readonly removeDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: `remove`
+     * is the word the remove control announces before the tag's own label, so it
+     * reads "Remove Design" rather than "Remove".
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TagMessages> | undefined>;
+    /** One output for one transition, carrying the reason, the event and `cancel()`. */
+    readonly remove: _angular_core.OutputEmitterRef<TagRemoveRequest>;
+    private readonly defaults;
+    private readonly group;
+    /** An explicit role the consumer wrote is never replaced by an inferred one. */
+    private readonly writtenRole;
+    /**
+     * One identifier for the chip, from which the label's and the hidden word's
+     * are derived. Deriving beats registering: the remove control needs the
+     * label's id before the body has had a chance to announce one.
+     */
+    readonly id: string;
+    readonly labelId: string;
+    readonly removeWordId: string;
+    /** Set by `slTagToggle`, which is the one member that holds a selection. */
+    private readonly selectedState;
+    protected readonly resolvedTone: _angular_core.Signal<TagTone>;
+    protected readonly resolvedVariant: _angular_core.Signal<TagVariant>;
+    protected readonly resolvedSize: _angular_core.Signal<TagSize>;
+    protected readonly resolvedShape: _angular_core.Signal<TagShape>;
+    protected readonly role: _angular_core.Signal<string | null>;
+    readonly selected: _angular_core.Signal<boolean>;
+    /** The family's words in the language in force, with this tag's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<TagMessages>;
+    readonly removeRefused: _angular_core.Signal<boolean>;
+    /** Called by the toggle, which owns the value and only reports it here. */
+    setSelected(selected: boolean): void;
+    /**
+     * The request the remove control and the keyboard both make. Nothing is
+     * committed here: the tag does not own whether it exists, and a consumer
+     * that refuses the request leaves the chip and the keyboard where they were.
+     */
+    requestRemoval(reason: TagRemoveReason, source: Event): void;
+    /**
+     * `Backspace` and `Delete` on a removable chip, which is the shortcut MUI,
+     * Primer, React Aria and Angular Material all ship. It is bound to the chip
+     * box rather than to either control, so it answers wherever focus is inside
+     * the chip, and a consumer's own handler runs first and can refuse it by
+     * calling `preventDefault`.
+     *
+     * A held key repeats, and a repeat would remove the chip focus has just
+     * landed on. The default is prevented because `Backspace` still navigates
+     * back in some browsers when nothing is being edited.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTag, "[slTag]", ["slTag"], { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "removeDisabled": { "alias": "removeDisabled"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The content box, and the primary target when there is one. It is written on
+ * the element the chip *is*: a `span` that does nothing, a `button` that runs
+ * a command, an `a` that navigates. The element is the member, which is what
+ * keeps `routerLink`, `type`, `download` and every native listener on the
+ * element that owns them.
+ *
+ * `disabled` belongs to the chip rather than to this element, because a chip
+ * is unavailable as a whole. What that means depends on the element, and the
+ * platform only offers one of the two forms per element.
+ */
+declare class SlTagBody {
+    protected readonly tag: SlTag;
+    private readonly element;
+    private readonly renderer;
+    private readonly isButton;
+    private readonly isAnchor;
+    protected readonly nativelyDisabled: _angular_core.Signal<"" | null>;
+    protected readonly ariaDisabled: _angular_core.Signal<"true" | null>;
+    /** An anchor without a destination is no longer a link, so it says it is one. */
+    protected readonly anchorRole: _angular_core.Signal<"link" | null>;
+    /**
+     * A disabled anchor keeps its place in the tab sequence and loses its
+     * destination, which is the line `link` draws for the same case: an anchor
+     * without an `href` would drop out of the tab sequence and take its own
+     * explanation with it. The attribute is withheld rather than overwritten, so
+     * it is given back the moment the chip becomes available again.
+     */
+    private withheldHref;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTagBody, "[slTagBody]", ["slTagBody"], {}, {}, never, ["[slTagStart]", "*", "[slTagEnd]"], true, never>;
+}
+
+/**
+ * A glyph or an avatar before the words. The artwork is the consumer's, and
+ * the part gives it a box that is sized and centred; the directive is written
+ * on the element the page already has, so nothing is wrapped.
+ */
+declare class SlTagStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTagStart, "[slTagStart]", ["slTagStart"], {}, {}, never, never, true, never>;
+}
+/** A glyph after the words. */
+declare class SlTagEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTagEnd, "[slTagEnd]", ["slTagEnd"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The run of tags, and the keyboard that belongs to it.
+ *
+ * It is a toolbar: the APG pattern for "a container for grouping a set of
+ * controls, such as buttons". One tab stop, arrow keys between the controls
+ * inside it, `Home` and `End` at the ends. React Aria and Angular Material
+ * reach for the Grid pattern instead, which buys a second axis at the price of
+ * two wrapper elements per chip and a `gridcell` role over every button; a
+ * single wrapping run does not need the second axis.
+ *
+ * Writing `role="list"` on the element turns the keyboard off and makes every
+ * chip a `listitem`. A list is a structure rather than a widget, its items are
+ * not controls to move between, and a screen reader announces its length.
+ */
+declare class SlTagGroup {
+    /** Which way the run reads. `vertical` also writes `aria-orientation`. */
+    readonly orientation: _angular_core.InputSignal<TagOrientation>;
+    /** Whether the arrow keys wrap past the ends of the run. */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly element;
+    private readonly writtenRole;
+    protected readonly role: _angular_core.Signal<string>;
+    private readonly roving;
+    protected readonly ariaOrientation: _angular_core.Signal<"vertical" | null>;
+    /** What a chip inside this run calls itself. A toolbar's items are its controls. */
+    readonly itemRole: _angular_core.Signal<"listitem" | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTagGroup, "[slTagGroup]", ["slTagGroup"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The control at the end of the chip, on the consumer's own button so its
+ * listeners and its attributes stay theirs. The glyph is the family's `x`,
+ * drawn as the `Glyph` element unless the consumer wrote content of their own:
+ * a character is never an icon.
+ *
+ * Its name is composed rather than repeated. The hidden word and the tag's own
+ * label are joined by `aria-labelledby`, so it announces "Remove Design"
+ * without the consumer writing the value a second time — the string four of
+ * the surveyed implementations make the consumer keep in step with the value
+ * by hand. Text referenced by `aria-labelledby` counts even when the element
+ * holding it is hidden, which is what lets the word cost no space.
+ */
+declare class SlTagRemove {
+    protected readonly tag: SlTag;
+    protected readonly labelledBy: _angular_core.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagRemove, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTagRemove, "button[slTagRemove]", ["slTagRemove"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A chip that holds a selection: a filter that is on, a facet that is chosen.
+ * Carbon calls it a selectable tag, Ant a checkable tag, Fluent a selected
+ * tag — and none of them ships the uncontrolled half, so a filter bar cannot
+ * be written without a piece of application state for every chip in it.
+ *
+ * It announces `aria-pressed` rather than `aria-selected`, which is a
+ * deliberate departure with a cost: `aria-selected` is only valid inside a
+ * `listbox`, a `grid` or a `tree`, and an `option` may not contain the remove
+ * control this family puts beside the label. The family keeps `selected` as
+ * its own word and writes `data-selected` for styling.
+ *
+ * The label never changes with the state — the APG's rule for a toggle — so
+ * "Aberto" stays "Aberto" and the state is announced beside it.
+ */
+declare class SlTagToggle {
+    /** Present means controlled, for the life of the component. */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly defaultSelected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * One output for one transition, carrying the value, the value it replaces,
+     * the reason, the originating event and `cancel()`. There is no
+     * `[(selected)]` because a two-way binding has one slot and cannot carry any
+     * of those, and a second output for the same transition would be the same
+     * failure stated twice.
+     */
+    readonly selectedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    protected readonly tag: SlTag;
+    private readonly state;
+    protected readonly isSelected: Signal<boolean>;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTagToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTagToggle, "button[slTagToggle]", ["slTagToggle"], { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "defaultSelected": { "alias": "defaultSelected"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; }, never, ["[slTagStart]", "*", "[slTagEnd]"], true, never>;
+}
+
+export { SlTag, SlTagBody, SlTagEnd, SlTagGroup, SlTagRemove, SlTagStart, SlTagToggle, TAG_DEFAULTS, injectTagDefaults, provideTagDefaults };
+export type { TagDefaults, TagOrientation, TagRemoveReason, TagRemoveRequest, TagShape, TagSize, TagTone, TagVariant };
+//# sourceMappingURL=slotted-angular-tag.d.ts.map

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

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