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

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

@@ -0,0 +1,340 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, ToastMessages } from '@slotted/core/i18n';
+import * as _slotted_angular_toast from '@slotted/angular/toast';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal, InjectionToken, Injector } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ToastMessage, ToastStore, ToastPriority, ToastStatus, ToastReason } from '@slotted/core/toast';
+export { ToastMessage, ToastPriority, ToastReason, ToastStatus, ToastStore } from '@slotted/core/toast';
+
+/** Which of the five semantic colours the message speaks in. */
+type ToastTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/**
+ * How that colour is painted. `raised` is the neutral surface with the tone in
+ * the mark, and it is the default: a message floats over content this family
+ * does not own, and tinting that content's corner is not its decision.
+ */
+type ToastVariant = 'raised' | 'soft' | 'solid';
+/** Which edge of the screen — or of the panel — the region sits at. */
+type ToastPlacement = 'top-start' | 'top' | 'top-end' | 'bottom-start' | 'bottom' | 'bottom-end';
+/**
+ * Where the region is rendered. One axis with three values rather than two
+ * booleans that admit a meaningless combination.
+ */
+type ToastAttach = 'portal' | 'viewport' | 'inline';
+/** Whether the messages stand in a column or in a pile that opens. */
+type ToastStacking = 'list' | 'stack';
+
+/**
+ * What a message carries for rendering. Opaque to `@slotted/core/toast`, which
+ * reads four fields out of the call and never looks in here.
+ */
+interface ToastContent {
+    title?: string;
+    description?: string;
+    tone?: ToastTone;
+    variant?: ToastVariant;
+    hideIcon?: boolean;
+    dismissible?: boolean;
+    progress?: boolean;
+    /**
+     * The controls that act on the message, and the whole body when a message
+     * needs one. A `TemplateRef` rather than a string, because Angular's answer
+     * to "content the consumer writes" is a template it renders per message —
+     * lazily, and with the message in its context, which is what
+     * `MAT_SNACK_BAR_DATA` gives a Material consumer by another route.
+     */
+    actions?: TemplateRef<{
+        $implicit: ToastMessage<ToastContent>;
+    }>;
+    body?: TemplateRef<{
+        $implicit: ToastMessage<ToastContent>;
+    }>;
+    /** Anything the consumer's own template reads. */
+    data?: unknown;
+}
+/** Everything one call can say about a message. */
+interface ToastInput extends ToastContent {
+    id?: string;
+    /** Milliseconds on screen. `0` never expires. */
+    duration?: number;
+    /** How loudly the announcer says it. Never inferred from the tone. */
+    priority?: ToastPriority;
+    /** What a reader hears. Built from the title and the description when unstated. */
+    announcement?: string;
+    /** Waiting on a promise: it does not expire and it draws no countdown. */
+    loading?: boolean;
+    onStatusChange?: (status: ToastStatus | 'removed', message: ToastMessage<ToastContent>) => void;
+}
+interface ToastPromiseInput<Value> {
+    loading: ToastInput;
+    success: ToastInput | ((value: Value) => ToastInput);
+    error: ToastInput | ((reason: unknown) => ToastInput);
+}
+interface ToastDefaults {
+    placement: ToastPlacement;
+    attach: ToastAttach;
+    stacking: ToastStacking;
+    tone: ToastTone;
+    variant: ToastVariant;
+    priority: ToastPriority;
+    dismissible: boolean;
+    swipe: boolean;
+    progress: boolean;
+    pauseOnHover: boolean;
+    pauseWhenHidden: boolean;
+    limit: number;
+    duration: number;
+    swipeThreshold: number;
+    hotkey: string;
+}
+/**
+ * The key that moves focus into the region. Five surveyed implementations ship
+ * a shortcut and no two chose the same key; `F6` is the one two of them chose
+ * for the reason that generalises — it is the landmark-navigation key.
+ */
+declare const TOAST_HOTKEY = "F6";
+declare const TOAST_DEFAULTS: InjectionToken<ToastDefaults>;
+/**
+ * An application decides once where its messages appear and how long they
+ * stay. A region or a message that states any of them still wins: an explicit
+ * value is never overridden by the token. The region's name and the close
+ * control's come from the language in force (`provideSlotted`).
+ */
+declare function provideToastDefaults(defaults: Partial<ToastDefaults>): {
+    provide: InjectionToken<ToastDefaults>;
+    useFactory: () => ToastDefaults;
+};
+/** What a region renders as here, before it states anything of its own. */
+declare function injectToastDefaults(): ToastDefaults;
+/**
+ * The imperative facade, and the observable model, which
+ * `docs/component-features.md` §14 asks for in one sentence.
+ *
+ * It is `providedIn: 'root'` because that is the surface Angular Material's
+ * consumers already know: a message is shown from an interceptor, a resolver or
+ * an effect, none of which is anywhere near a component. The reads are signals,
+ * so a zoneless application renders on them without a `markForCheck` anywhere.
+ */
+declare class SlToastService {
+    private readonly defaults;
+    /** The model a region renders. Also the escape hatch for a page's own host. */
+    readonly store: ToastStore<ToastContent>;
+    private readonly snapshot;
+    /** The messages on screen, newest first. */
+    readonly visible: Signal<readonly ToastMessage<ToastContent>[]>;
+    /** The messages waiting behind the limit. A page may say how many. */
+    readonly queued: Signal<readonly ToastMessage<ToastContent>[]>;
+    /** Whether every clock is held. */
+    readonly paused: Signal<boolean>;
+    constructor();
+    /** Adds a message, or updates the one that already carries this id. */
+    show(input?: ToastInput): string;
+    /** Changes a message already in the queue, keeping its place. */
+    update(id: string, input: ToastInput): void;
+    /** Asks for a message to leave, carrying the reason. */
+    dismiss(id: string, reason?: ToastReason): void;
+    /** Asks for every message to leave at once — a route change, a sign-out. */
+    clear(reason?: ToastReason): void;
+    pauseAll(): void;
+    resumeAll(): void;
+    /** A message that follows a promise: loading, then success or failure. */
+    promise<Value>(promise: Promise<Value>, input: ToastPromiseInput<Value>): Promise<Value>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * One message: everything about it that is behaviour rather than markup.
+ *
+ * It is a directive rather than a component so a page that writes its own list
+ * — from `SlToastService.visible()` and nothing else — gets the timer, the
+ * exit, the swipe and the keyboard by putting one attribute on its own `li`.
+ */
+declare class SlToastItem {
+    readonly message: _angular_core.InputSignal<ToastMessage<ToastContent>>;
+    /** How far this message is from the front of the pile. The stylesheet reads it. */
+    readonly index: _angular_core.InputSignal<number>;
+    private readonly region;
+    private readonly host;
+    /**
+     * The message's own injector, handed to a page's body template so the parts
+     * inside it — the mark's glyph above all — read this message and not the
+     * place the template was declared.
+     */
+    readonly injector: Injector;
+    private readonly status;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    private readonly offset;
+    private drag;
+    readonly tone: _angular_core.Signal<ToastTone>;
+    /**
+     * The glyph the tone's mark draws: none while a promise is in flight, when
+     * the mark is `progress-indicator`'s contained loader, and none for
+     * `secondary`, a neutral message with no severity to state.
+     */
+    readonly mark: _angular_core.Signal<"check" | "minus" | "plus" | "dot" | "x" | "ellipsis" | "copy" | "eye" | "eye-off" | "chevron-right" | "chevron-down" | "chevrons-right" | "panel-open" | "panel-close" | "arrow-left" | "pin" | "pin-off" | "external" | "calendar" | "clock" | "person" | "circle" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "stop" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "upload" | "file" | "trash" | "play" | "pause" | "rotate-ccw" | "file-image" | "file-text" | "file-spreadsheet" | "file-audio" | "file-video" | "file-archive" | "file-type" | "presentation" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check" | null>;
+    protected readonly variant: _angular_core.Signal<_slotted_angular_toast.ToastVariant>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly durationValue: _angular_core.Signal<string | null>;
+    protected readonly swipeX: _angular_core.Signal<string | null>;
+    protected readonly swipeY: _angular_core.Signal<string | null>;
+    /**
+     * `packages/core/src/presence` reads the exit the stylesheet declares and
+     * completes it on a timer when the browser never reports one — a backgrounded
+     * tab, a `display: none` ancestor. Ark guesses two hundred milliseconds
+     * instead, and a message caught by any of those cases never leaves.
+     */
+    private readonly presence;
+    constructor();
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastItem, "li[slToastItem]", ["slToastItem"], { "message": { "alias": "slToastItem"; "required": true; "isSignal": true; }; "index": { "alias": "slToastItemIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The place transient messages appear, and the only part of this family a page
+ * renders directly.
+ *
+ * **It is a landmark, not a live region.** A live role on a box holding a Close
+ * and an Undo is read with both buttons inside the sentence, and a region
+ * created in the same task as its text is silent under ARIA 1.2 §6.4. The words
+ * are spoken by `packages/core/src/live-announcer`; this element is what a
+ * reader navigates to, with the hotkey or with their own landmark list.
+ *
+ * **It never takes focus.** The APG's Alert pattern is explicit that an
+ * arriving message must not affect the keyboard, and the whole of this family's
+ * claim on it is one key the reader presses.
+ */
+declare class SlToastRegion {
+    /** Defaults to the token, then to `bottom-end`. */
+    readonly placement: _angular_core.InputSignal<ToastPlacement | undefined>;
+    /** Defaults to the token, then to `portal`. */
+    readonly attach: _angular_core.InputSignal<ToastAttach | undefined>;
+    /** Defaults to the token, then to `list`. */
+    readonly stacking: _angular_core.InputSignal<ToastStacking | undefined>;
+    readonly swipe: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly limit: _angular_core.InputSignal<number | undefined>;
+    readonly duration: _angular_core.InputSignal<number | undefined>;
+    readonly pauseOnHover: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly pauseWhenHidden: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** The key that moves focus into the region. Defaults to the token. */
+    readonly hotkey: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the name
+     * a reader finds the region by (`label`) and what each close control
+     * announces (`close`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ToastMessages> | undefined>;
+    /** The element a portalled region is placed inside. */
+    readonly container: _angular_core.InputSignal<Element | null | undefined>;
+    /** The queue the page owns. Present at all decides the mode for good. */
+    readonly toasts: _angular_core.InputSignal<readonly ToastMessage<ToastContent>[] | undefined>;
+    /**
+     * One output for one transition, carrying the value, the value it replaces,
+     * the reason, the originating event and `cancel()`. There is no `[(toasts)]`
+     * because a two-way binding has one slot and cannot carry any of those — the
+     * shape `alert` settled.
+     */
+    readonly toastsChange: _angular_core.OutputEmitterRef<ChangeRequest<readonly ToastMessage<ToastContent>[]>>;
+    readonly defaults: _slotted_angular_toast.ToastDefaults;
+    /** The family's words in the language in force, with this region's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ToastMessages>;
+    private readonly service;
+    private readonly layer;
+    private readonly host;
+    private readonly browser;
+    /**
+     * A region the page's own array feeds cannot share the injected service: the
+     * mode is decided once, for the life of the store, and the service's store is
+     * uncontrolled by construction.
+     */
+    private readonly ownStore;
+    readonly store: ToastStore<ToastContent>;
+    private readonly snapshot;
+    readonly visible: _angular_core.Signal<readonly ToastMessage<ToastContent>[]>;
+    readonly queued: _angular_core.Signal<readonly ToastMessage<ToastContent>[]>;
+    readonly paused: _angular_core.Signal<boolean>;
+    readonly resolvedPlacement: _angular_core.Signal<ToastPlacement>;
+    readonly resolvedAttach: _angular_core.Signal<ToastAttach>;
+    readonly resolvedStacking: _angular_core.Signal<ToastStacking>;
+    readonly resolvedSwipe: _angular_core.Signal<boolean>;
+    readonly resolvedHotkey: _angular_core.Signal<string>;
+    private readonly interacting;
+    /** Where the keyboard was before the hotkey moved it into the region. */
+    private cameFrom;
+    constructor();
+    /** Sends the keyboard to the newest message. The family never does it alone. */
+    focus(): void;
+    protected onPointer(inside: boolean): void;
+    protected onFocus(inside: boolean): void;
+    protected onFocusOut(event: FocusEvent): void;
+    private report;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastRegion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToastRegion, "sl-toast-region", ["slToastRegion"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "stacking": { "alias": "stacking"; "required": false; "isSignal": true; }; "swipe": { "alias": "swipe"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "pauseWhenHidden": { "alias": "pauseWhenHidden"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "toasts": { "alias": "toasts"; "required": false; "isSignal": true; }; }, { "toastsChange": "toastsChange"; }, never, never, true, never>;
+}
+
+/**
+ * The parts, for a page that writes its own message body inside
+ * `<ng-template slToastBody>` rather than taking the family's.
+ *
+ * They carry the part name and nothing else: the geometry, the tone and the
+ * states are the item's and the region's, and a directive that repeated any of
+ * them would be a second place to change them. The two that draw a glyph read
+ * it from the item they sit in.
+ */
+/**
+ * The tone's mark, or the page's own. Content the page writes replaces it;
+ * with none, the item's glyph is drawn, `progress-indicator`'s contained
+ * loader while the message waits, and nothing for `secondary`.
+ */
+declare class SlToastIcon {
+    private readonly item;
+    protected readonly mark: _angular_core.Signal<"check" | "minus" | "plus" | "dot" | "x" | "ellipsis" | "copy" | "eye" | "eye-off" | "chevron-right" | "chevron-down" | "chevrons-right" | "panel-open" | "panel-close" | "arrow-left" | "pin" | "pin-off" | "external" | "calendar" | "clock" | "person" | "circle" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "stop" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "upload" | "file" | "trash" | "play" | "pause" | "rotate-ccw" | "file-image" | "file-text" | "file-spreadsheet" | "file-audio" | "file-video" | "file-archive" | "file-type" | "presentation" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check" | null>;
+    protected readonly loading: _angular_core.Signal<boolean>;
+    protected readonly tone: _angular_core.Signal<_slotted_angular_toast.ToastTone>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToastIcon, "[slToastIcon]", ["slToastIcon"], {}, {}, never, ["*"], true, never>;
+}
+/** The words, and the one column that is allowed to shrink. */
+declare class SlToastContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastContent, "[slToastContent]", ["slToastContent"], {}, {}, never, never, true, never>;
+}
+/**
+ * The message's name. Written on the page's own element, and not a heading: a
+ * message that is gone in five seconds is not a section of the document.
+ */
+declare class SlToastTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastTitle, "[slToastTitle]", ["slToastTitle"], {}, {}, never, never, true, never>;
+}
+/** The message. Written on a `p`, which is what a sentence of prose is. */
+declare class SlToastDescription {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastDescription, "[slToastDescription]", ["slToastDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * The controls that act on the message. What goes in is the page's own
+ * buttons: `button` already owns what a button is.
+ */
+declare class SlToastActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastActions, "[slToastActions]", ["slToastActions"], {}, {}, never, never, true, never>;
+}
+/** The control that puts the message away. A real button with a real name. */
+declare class SlToastClose {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToastClose, "button[slToastClose]", ["slToastClose"], {}, {}, never, ["*"], true, never>;
+}
+/** How much of the duration is left, drawn from the number the timer reads. */
+declare class SlToastProgress {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToastProgress, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToastProgress, "[slToastProgress]", ["slToastProgress"], {}, {}, never, never, true, never>;
+}
+
+export { SlToastActions, SlToastClose, SlToastContent, SlToastDescription, SlToastIcon, SlToastItem, SlToastProgress, SlToastRegion, SlToastService, SlToastTitle, TOAST_DEFAULTS, TOAST_HOTKEY, injectToastDefaults, provideToastDefaults };
+export type { ToastAttach, ToastContent, ToastDefaults, ToastInput, ToastPlacement, ToastPromiseInput, ToastStacking, ToastTone, ToastVariant };
+//# sourceMappingURL=slotted-angular-toast.d.ts.map

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

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

package/types/slotted-angular-toggle-group.d.ts

@@ -0,0 +1,167 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the group and every item inside it sit at. */
+type ToggleGroupSize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the items are framed or bare. `ghost` is the bar that sits inside
+ * something already framed — a toolbar, a card header. There is no tone axis:
+ * "on" is one colour across the system, and a bar that wants the whole palette
+ * is `button-group` around toggle buttons.
+ */
+type ToggleGroupVariant = 'outline' | 'ghost';
+/** How the items flow. The arrows follow the same axis. */
+type ToggleGroupOrientation = 'horizontal' | 'vertical';
+interface ToggleGroupDefaults {
+    attached: boolean;
+    deselectable: boolean;
+    loop: boolean;
+    orientation: ToggleGroupOrientation;
+    size: ToggleGroupSize;
+    variant: ToggleGroupVariant;
+}
+declare const TOGGLE_GROUP_DEFAULTS: InjectionToken<ToggleGroupDefaults>;
+/**
+ * An application decides once how its toggle bars are drawn and how they
+ * behave, rather than repeating the same inputs on every one of them. A group
+ * that states any of them itself still wins.
+ */
+declare function provideToggleGroupDefaults(defaults: Partial<ToggleGroupDefaults>): {
+    provide: InjectionToken<ToggleGroupDefaults>;
+    useFactory: () => ToggleGroupDefaults;
+};
+/** What a toggle group renders as here, before it states anything of its own. */
+declare function injectToggleGroupDefaults(): ToggleGroupDefaults;
+
+/** Why the value moved. A toggle group can produce exactly these two. */
+type ToggleGroupSelectionReason = 'pointer' | 'keyboard';
+/**
+ * A set of two-state buttons that share one value.
+ *
+ * **The arrows move focus and never toggle.** Each item is the APG Button
+ * pattern's toggle button, activated by `Space` and `Enter` alone; the
+ * movement between them is the Toolbar pattern's roving tabindex. The family
+ * whose arrows move the value is `segmented-control`, and it is a radio group
+ * because that is the pattern describing that interaction.
+ *
+ * **Inside a `toolbar` the group stands down.** A bar is one tab stop with
+ * arrow navigation across every control it holds, so a group running a second
+ * ring inside it would put two tab stops where the APG asks for one. The bar is
+ * found in the DOM by its public identifier rather than by injecting the other
+ * family, so neither depends on the other; `rovingFocus` states it outright
+ * for a bar this library did not write.
+ *
+ * **The value is always an array.** `multiple` caps it at one entry rather
+ * than changing its type, so both bindings hold one shape and a `model()` can
+ * hold it. A single-select consumer writes an array of one, which is the price.
+ */
+declare class SlToggleGroup implements OnInit {
+    /** Present means the consumer owns the set. */
+    readonly value: _angular_core.InputSignal<readonly string[] | undefined>;
+    /** The value an uncontrolled group starts from, read once. */
+    readonly defaultValue: _angular_core.InputSignal<readonly string[] | undefined>;
+    /** Whether more than one item may be on at a time. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the last item on may be turned off. Ignored while `multiple` is
+     * true, where a set may always empty.
+     */
+    readonly deselectable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly size: _angular_core.InputSignal<ToggleGroupSize | undefined>;
+    readonly variant: _angular_core.InputSignal<ToggleGroupVariant | undefined>;
+    readonly orientation: _angular_core.InputSignal<ToggleGroupOrientation | undefined>;
+    readonly attached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Unstated rather than `false`, so an item may state its own. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Whether the group holds one tab stop of its own. Unstated, it is inferred
+     * from the bar it is in.
+     */
+    readonly rovingFocus: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    private readonly host;
+    private readonly defaults;
+    private readonly writtenRole;
+    private readonly writtenOrientation;
+    private readonly own;
+    private readonly insideToolbar;
+    private handle;
+    readonly selection: _angular_core.Signal<readonly string[]>;
+    readonly resolvedSize: _angular_core.Signal<ToggleGroupSize>;
+    readonly resolvedVariant: _angular_core.Signal<ToggleGroupVariant>;
+    readonly resolvedOrientation: _angular_core.Signal<ToggleGroupOrientation>;
+    readonly resolvedAttached: _angular_core.Signal<boolean>;
+    readonly resolvedDeselectable: _angular_core.Signal<boolean>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedRovingFocus: _angular_core.Signal<boolean>;
+    /** A consumer's own wins. The family writes `group` and never `toolbar`. */
+    protected readonly resolvedRole: string;
+    /**
+     * Written only when the group flows the other way: `group` carries no
+     * implied orientation, so the attribute says something exactly when the
+     * arrows have moved to the block axis.
+     */
+    protected readonly ariaOrientation: _angular_core.Signal<string | null>;
+    constructor();
+    ngOnInit(): void;
+    /** An item joined or left the set, so the ring re-reads what it moves between. */
+    refresh(): void;
+    /** Whether one value is on. Read by every item in the set. */
+    holds(value: string): boolean;
+    /** Asks the group to turn one value on or off. */
+    toggle(value: string, reason: ToggleGroupSelectionReason, source: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggleGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToggleGroup, "[slToggleGroup]", ["slToggleGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "deselectable": { "alias": "deselectable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rovingFocus": { "alias": "rovingFocus"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The mark an item is drawn with, on the consumer's own element.
+ *
+ * A directive rather than a slot, so an `ng-icon`, an inline `svg` or a `span`
+ * all work and none of them loses its own semantics. It is hidden from the
+ * reading order, because the words beside it — or the `aria-label` on the
+ * button — are what a reader hears.
+ */
+declare class SlToggleGroupIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggleGroupIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToggleGroupIcon, "[slToggleGroupIcon]", ["slToggleGroupIcon"], {}, {}, never, never, true, never>;
+}
+/**
+ * One two-state button of the set.
+ *
+ * `aria-pressed` is written in both states, so the item is announced as a
+ * toggle rather than as a button that happens to be pressed — and its label
+ * never changes with its state, which the APG Button pattern calls critical.
+ *
+ * It is a part of `toggle-group` and not an entry point of its own:
+ * `SlToggleGroup` is injected without `optional`, so an item written outside a
+ * group fails at construction rather than rendering a button that toggles
+ * nothing.
+ */
+declare class SlToggleGroupItem {
+    /** What this item turns on. It is what the group's value holds. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Unstated rather than `false`, so the item defers to the group. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * The group the item belongs to. Public, because a consumer reaching the
+     * item through `exportAs` may want the group's resolved step.
+     */
+    readonly group: SlToggleGroup;
+    readonly pressed: _angular_core.Signal<boolean>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    protected readonly disabledAttribute: _angular_core.Signal<"" | null>;
+    constructor();
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggleGroupItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToggleGroupItem, "button[slToggleGroupItem]", ["slToggleGroupItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["[slToggleGroupIcon]", "*"], true, never>;
+}
+
+export { SlToggleGroup, SlToggleGroupIcon, SlToggleGroupItem, TOGGLE_GROUP_DEFAULTS, injectToggleGroupDefaults, provideToggleGroupDefaults };
+export type { ToggleGroupDefaults, ToggleGroupOrientation, ToggleGroupSelectionReason, ToggleGroupSize, ToggleGroupVariant };
+//# sourceMappingURL=slotted-angular-toggle-group.d.ts.map

package/types/slotted-angular-toggle-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-toggle-group.d.ts","sources":["../../toggle-group/src/toggle-group-defaults.ts","../../toggle-group/src/toggle-group.ts","../../toggle-group/src/toggle-group-parts.ts"],"mappings":";;;;AAEA;AACM,KAAM,eAAe;AAE3B;;;;;AAKG;KACS,kBAAkB;AAE9B;KACY,sBAAsB;UAEjB,mBAAmB;;;;iBAIrB,sBAAsB;UAC7B,eAAe;aACZ,kBAAkB;AAC5B;AAWD,cAAa,qBAAqB,EAAA,cAAA,CAAA,mBAAA;AAKlC;;;;AAIG;AACH,iBAAgB,0BAA0B,WAAW,OAAO,CAAC,mBAAmB;;sBAG5D,mBAAmB;AAEtC;AAED;AACA,iBAAgB,yBAAyB,IAAI,mBAAmB;;AChBhE;KACY,0BAA0B;AAKtC;;;;;;;;;;;;;;;;;;;AAmBG;AACH,cAoBa,aAAc,YAAW,MAAM;;oBAE5B,aAAA,CAAA,WAAA;;2BAEO,aAAA,CAAA,WAAA;;uBAEJ,aAAA,CAAA,wBAAA;AACjB;;;AAGG;2BACkB,aAAA,CAAA,wBAAA;mBAGR,aAAA,CAAA,WAAA,CAAA,eAAA;sBACG,aAAA,CAAA,WAAA,CAAA,kBAAA;0BACI,aAAA,CAAA,WAAA,CAAA,sBAAA;uBACH,aAAA,CAAA,wBAAA;wBAGC,aAAA,CAAA,wBAAA;mBACL,aAAA,CAAA,wBAAA;;uBAII,aAAA,CAAA,wBAAA;AAGjB;;;AAGG;0BACiB,aAAA,CAAA,wBAAA;;0BAKA,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEpB;AACA;AACA;AACA;AAIA;AACA;;wBAGkB,aAAA,CAAA,MAAA;2BACG,aAAA,CAAA,MAAA,CAAA,eAAA;8BACG,aAAA,CAAA,MAAA,CAAA,kBAAA;kCACI,aAAA,CAAA,MAAA,CAAA,sBAAA;+BACH,aAAA,CAAA,MAAA;mCACI,aAAA,CAAA,MAAA;2BACR,aAAA,CAAA,MAAA;+BACI,aAAA,CAAA,MAAA;kCACG,aAAA,CAAA,MAAA;;AAG5B;AACA;;;;AAIG;AACH,wCAAkC,aAAA,CAAA,MAAA;;;;;;AAgDlC;;kCAK8B,0BAA0B,UAAU,KAAK;oDAxH5D,aAAa;sDAAb,aAAa;AAoJzB;;ACvND;;;;;;;AAOG;AACH,cASa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;AAWjC;;;;;;;;;;;AAWG;AACH,cAkBa,iBAAiB;;oBAEd,aAAA,CAAA,WAAA;;uBAEG,aAAA,CAAA,wBAAA;AAIjB;;;AAGG;oBACW,aAAA;sBAEE,aAAA,CAAA,MAAA;+BACS,aAAA,CAAA,MAAA;AAEzB,0CAAoC,aAAA,CAAA,MAAA;;AASpC,6BAAyB,KAAK;oDA1BnB,iBAAiB;sDAAjB,iBAAiB;AA6B7B;;","names":[]}

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

@@ -0,0 +1,106 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the control sits at. */
+type ToggleSize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the control is framed or bare. `ghost` is the toggle that sits
+ * inside something already framed — a toolbar, a card header. There is no
+ * tone axis: a mode is one colour when it is on, and an action that persists
+ * in one of five tones is `SlToggleButton`.
+ */
+type ToggleVariant = 'outline' | 'ghost';
+interface ToggleDefaults {
+    size: ToggleSize;
+    variant: ToggleVariant;
+}
+declare const TOGGLE_DEFAULTS: InjectionToken<ToggleDefaults>;
+/**
+ * An application decides once how its toggles are drawn — a toolbar of ghost
+ * modes, a form of framed ones — rather than repeating the two inputs on
+ * every control. A toggle that states either itself still wins.
+ */
+declare function provideToggleDefaults(defaults: Partial<ToggleDefaults>): {
+    provide: InjectionToken<ToggleDefaults>;
+    useFactory: () => ToggleDefaults;
+};
+/** What a toggle renders as here, before it states anything of its own. */
+declare function injectToggleDefaults(): ToggleDefaults;
+
+/** Why the state moved. A toggle can produce exactly these two. */
+type TogglePressedReason = 'pointer' | 'keyboard';
+/**
+ * The mark beside the words, or the whole content of an icon-only toggle. A
+ * marker on the consumer's own element rather than a wrapper, so an `svg`, an
+ * `sl-icon` and a masked `span` all work and none loses its own semantics. It
+ * is hidden from the reading order, because the words beside it — or the
+ * `aria-label` on the button — are what a reader hears.
+ */
+declare class SlToggleIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggleIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlToggleIcon, "[slToggleIcon]", ["slToggleIcon"], {}, {}, never, never, true, never>;
+}
+/**
+ * A two-state button standing on its own: a mode — Bold, Wrap, Pin — that is
+ * true the moment it is pressed. `aria-pressed` is written in both states, so
+ * the control is announced as a toggle rather than as a button that happens
+ * to be pressed, and its label never changes with its state, which the APG
+ * Button pattern calls critical.
+ *
+ * `SlToggleButton` is the other member: an action that persists — Follow,
+ * Subscribe — which reaches a server and waits, in one of five tones. The two
+ * hold one state model and one output shape, so a consumer moving between
+ * them changes no handler. Inside `slToolbar` the bar owns the tab stop and
+ * the arrows, and this control writes no listener of its own.
+ *
+ * The component is a directive on the element the consumer wrote, so
+ * substituting the element is writing a different one — and it has to stay a
+ * `button`: `aria-pressed` on a link is a link announcing a state a link does
+ * not hold.
+ */
+declare class SlToggle implements AfterViewInit {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<ToggleSize | undefined>;
+    readonly variant: _angular_core.InputSignal<ToggleVariant | undefined>;
+    /** Present means controlled, for the life of the component. */
+    readonly pressed: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** The value an uncontrolled toggle starts from, read once. */
+    readonly defaultPressed: _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
+     * `[(pressed)]` because a two-way binding has one slot and cannot carry any
+     * of those — the reason `SlToggleButton` records for the same choice.
+     */
+    readonly pressedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly defaults;
+    private readonly element;
+    private readonly destroyRef;
+    /**
+     * A `type` the consumer wrote survives: a toggle inside a form is a
+     * `button` unless the consumer says `submit`, and the attribute is read
+     * before the host binding writes it.
+     */
+    private readonly writtenType;
+    protected readonly type: string;
+    private readonly own;
+    readonly isPressed: _angular_core.Signal<boolean>;
+    readonly resolvedSize: _angular_core.Signal<ToggleSize>;
+    readonly resolvedVariant: _angular_core.Signal<ToggleVariant>;
+    /**
+     * After the view, not in the constructor. A `(click)` written on the same
+     * element is bound when the view is created, so a listener registered any
+     * earlier runs first and reads `defaultPrevented` before the consumer has
+     * had the chance to set it — and a refused activation would move the state
+     * anyway.
+     */
+    ngAfterViewInit(): void;
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToggle, "button[slToggle]", ["slToggle"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "defaultPressed": { "alias": "defaultPressed"; "required": false; "isSignal": true; }; }, { "pressedChange": "pressedChange"; }, never, ["[slToggleIcon]", "*"], true, never>;
+}
+
+export { SlToggle, SlToggleIcon, TOGGLE_DEFAULTS, injectToggleDefaults, provideToggleDefaults };
+export type { ToggleDefaults, TogglePressedReason, ToggleSize, ToggleVariant };
+//# sourceMappingURL=slotted-angular-toggle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-toggle.d.ts","sources":["../../toggle/src/toggle-defaults.ts","../../toggle/src/toggle.ts"],"mappings":";;;;AAEA;AACM,KAAM,UAAU;AAEtB;;;;;AAKG;KACS,aAAa;UAER,cAAc;UACvB,UAAU;aACP,aAAa;AACvB;AAOD,cAAa,eAAe,EAAA,cAAA,CAAA,cAAA;AAK5B;;;;AAIG;AACH,iBAAgB,qBAAqB,WAAW,OAAO,CAAC,cAAc;;sBAGlD,cAAc;AAEjC;AAED;AACA,iBAAgB,oBAAoB,IAAI,cAAc;;AClBtD;KACY,mBAAmB;AAE/B;;;;;;AAMG;AACH,cASa,YAAY;oDAAZ,YAAY;sDAAZ,YAAY;AAAG;AAW5B;;;;;;;;;;;;;;;;;AAiBG;AACH,cAoBa,QAAS,YAAW,aAAa;uBAC3B,aAAA,CAAA,wBAAA;mBACJ,aAAA,CAAA,WAAA,CAAA,UAAA;sBACG,aAAA,CAAA,WAAA,CAAA,aAAA;;sBAGA,aAAA,CAAA,wBAAA;;6BAIO,aAAA,CAAA,wBAAA;AACvB;;;;;AAKG;4BACmB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEtB;AACA;AACA;AACA;;;;AAIG;AACH;AACA;AAEA;wBAEkB,aAAA,CAAA,MAAA;2BACG,aAAA,CAAA,MAAA,CAAA,UAAA;8BACG,aAAA,CAAA,MAAA,CAAA,aAAA;AAExB;;;;;;AAMG;;AAUH;oDApDW,QAAQ;sDAAR,QAAQ;AA6DpB;;","names":[]}