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

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

@@ -0,0 +1,198 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, StepperMessages } from '@slotted/core/i18n';
+import * as _slotted_core_steps from '@slotted/core/steps';
+import { StepOrientation } from '@slotted/core/steps';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+type StepperOrientation = StepOrientation;
+type StepperLabelPlacement = 'end' | 'bottom';
+/** What a step header is: a control, a destination, or neither. */
+type StepperNavigation = 'button' | 'link' | 'none';
+type StepperStepReason = 'pointer' | 'keyboard' | 'programmatic';
+declare const STEPPER_DEFAULT_ORIENTATION: StepperOrientation;
+declare const STEPPER_DEFAULT_LABEL_PLACEMENT: StepperLabelPlacement;
+declare const STEPPER_DEFAULT_NAVIGATION: StepperNavigation;
+interface StepperDefaults {
+    labelPlacement?: StepperLabelPlacement;
+    linear?: boolean;
+    navigation?: StepperNavigation;
+    orientation?: StepperOrientation;
+}
+declare const STEPPER_DEFAULTS_TOKEN: InjectionToken<StepperDefaults>;
+/**
+ * An application decides once which way its flows run, where the labels sit,
+ * whether a header can be pressed, and whether the order is enforced. A
+ * stepper that states any of those itself still wins: an explicit input is
+ * never overridden by the token. Its words come from the language in force
+ * (`provideSlotted`).
+ */
+declare function provideStepperDefaults(defaults: StepperDefaults): {
+    provide: InjectionToken<StepperDefaults>;
+    useValue: StepperDefaults;
+};
+declare function injectStepperDefaults(): StepperDefaults;
+
+/**
+ * Where the reader is in a sequence of steps, which steps they may reach, and
+ * the panel belonging to the step they are on.
+ *
+ * **It refuses the tab role.** Angular Material gives a horizontal stepper
+ * `role="tablist"`; section 7 of the feature guide forbids it in the Tabs entry
+ * itself — tabs are for peer views in one context, not for the steps of a
+ * process. What replaces it is `ol` and `li` for the sequence,
+ * `aria-current="step"` for where the reader is, and a visually hidden status
+ * inside each header so a reader hears "Step 2 of 5, completed" rather than
+ * "2".
+ *
+ * **It validates nothing.** A consumer refuses a move by cancelling the change
+ * request, which every mutable value in this library already carries. Zag ships
+ * `isStepValid` and `onStepInvalid` for that job; this family needs neither.
+ *
+ * **It never claims completion.** `complete` is the consumer's fact about one
+ * step; `autoComplete` is the shorthand for the flow where reaching step three
+ * does mean the first two are done, and it is off.
+ */
+declare class SlStepper {
+    /** Present means controlled, for the life of the component. */
+    readonly stepValue: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** What an uncontrolled stepper starts from, read once. */
+    readonly defaultStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * list's name (`label`), the position, and the status each step announces.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<StepperMessages> | undefined>;
+    readonly orientation: _angular_core.InputSignal<_slotted_core_steps.StepOrientation | undefined>;
+    readonly labelPlacement: _angular_core.InputSignal<StepperLabelPlacement | undefined>;
+    readonly navigation: _angular_core.InputSignal<StepperNavigation | undefined>;
+    readonly linear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly autoComplete: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted before the step moves, carrying what it replaces, the reason and
+     * the event. It is not the second half of a two-way binding: one slot can
+     * carry none of those, and cancelling the request is how a consumer refuses
+     * a move.
+     */
+    readonly stepChange: _angular_core.OutputEmitterRef<ChangeRequest<number>>;
+    private readonly defaults;
+    private readonly own;
+    private readonly steps;
+    readonly id: string;
+    readonly step: _angular_core.Signal<number>;
+    readonly count: _angular_core.Signal<number>;
+    readonly orientationValue: _angular_core.Signal<_slotted_core_steps.StepOrientation>;
+    readonly labelPlacementValue: _angular_core.Signal<StepperLabelPlacement>;
+    readonly navigationValue: _angular_core.Signal<StepperNavigation>;
+    readonly linearValue: _angular_core.Signal<boolean>;
+    /** The family's words in the language in force, with this stepper's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<StepperMessages>;
+    /** The locale in force: what the descriptors a step announces are listed in. */
+    readonly locale: _angular_core.Signal<string>;
+    /** How far along the row the reader has travelled, nought to a hundred. */
+    readonly percent: _angular_core.Signal<number>;
+    readonly canGoPrevious: _angular_core.Signal<boolean>;
+    readonly canGoNext: _angular_core.Signal<boolean>;
+    register(steps: readonly SlStepperStep[]): void;
+    statusOf(index: number): _slotted_core_steps.StepStatus;
+    reachable(index: number): boolean;
+    goToStep(next: number, reason?: StepperStepReason, source?: Event): void;
+    next(reason?: StepperStepReason, source?: Event): void;
+    previous(reason?: StepperStepReason, source?: Event): void;
+    reset(source?: Event): void;
+    triggerId(index: number): string;
+    panelId(index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlStepper, "[slStepper]", ["slStepper"], { "stepValue": { "alias": "step"; "required": false; "isSignal": true; }; "defaultStep": { "alias": "defaultStep"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "autoComplete": { "alias": "autoComplete"; "required": false; "isSignal": true; }; }, { "stepChange": "stepChange"; }, never, ["*"], true, never>;
+}
+/**
+ * The ordered list, and the one part that knows how many steps there are.
+ *
+ * The keyboard is handled here rather than on each header, because the
+ * destination of an arrow is another header and only the list knows them all.
+ * Every header stays in the tab sequence: the arrows are added on top of it
+ * rather than replacing it with a roving tab stop, which is the model a
+ * `tablist` has and the model this family declined.
+ */
+declare class SlStepperList {
+    private readonly stepper;
+    private readonly items;
+    private readonly element;
+    private readonly ownLabel;
+    readonly accessibleLabel: _angular_core.Signal<string>;
+    constructor();
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepperList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlStepperList, "ol[slStepperList]", ["slStepperList"], {}, {}, ["items"], never, true, never>;
+}
+/**
+ * One step: its marker, its name, the second line under it, and the connector
+ * that runs to the next one.
+ *
+ * A step a linear flow has not reached carries `aria-disabled` rather than
+ * `disabled`, so it stays in the tab sequence: a reader can find out the step
+ * exists and that it is not yet available.
+ */
+declare class SlStepperStep {
+    readonly stepper: SlStepper;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly complete: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    /** Written by the list, the only part that can see the whole sequence. */
+    readonly index: _angular_core.WritableSignal<number>;
+    readonly last: _angular_core.WritableSignal<boolean>;
+    readonly current: _angular_core.Signal<boolean>;
+    readonly travelled: _angular_core.Signal<boolean>;
+    readonly status: _angular_core.Signal<_slotted_core_steps.StepStatus>;
+    readonly unreachable: _angular_core.Signal<boolean>;
+    /**
+     * The glyph drawn over the number: a cross for a step in error, a check for
+     * a finished one the reader has left. The current step keeps its number
+     * even when it is also complete, because the number is what says where the
+     * reader is.
+     */
+    readonly mark: _angular_core.Signal<"calendar" | "upload" | "search" | "circle" | "stop" | "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" | "clock" | "person" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "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>;
+    /** A list of descriptors, written the way the locale in force lists them. */
+    readonly announced: _angular_core.Signal<string>;
+    activate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepperStep, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlStepperStep, "li[slStepperStep]", ["slStepperStep"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "complete": { "alias": "complete"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The content of the step it is written inside. It is a `group` labelled by its
+ * own header rather than a `tabpanel`, for the reason the root refuses the tab
+ * role, and it is focusable so a consumer moving focus after a step change has
+ * somewhere to put it.
+ */
+declare class SlStepperPanel {
+    readonly stepper: SlStepper;
+    readonly step: SlStepperStep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepperPanel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlStepperPanel, "[slStepperPanel]", ["slStepperPanel"], {}, {}, never, never, true, never>;
+}
+/**
+ * The two directives that move the flow, on the consumer's own button.
+ *
+ * Angular Material reaches the same shape with `matStepperNext`: a family that
+ * shipped its own advance button would ship a second button nobody could theme
+ * with the first.
+ */
+declare class SlStepperNext {
+    readonly stepper: SlStepper;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepperNext, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlStepperNext, "button[slStepperNext]", ["slStepperNext"], {}, {}, never, never, true, never>;
+}
+declare class SlStepperPrevious {
+    readonly stepper: SlStepper;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlStepperPrevious, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlStepperPrevious, "button[slStepperPrevious]", ["slStepperPrevious"], {}, {}, never, never, true, never>;
+}
+
+export { STEPPER_DEFAULTS_TOKEN, STEPPER_DEFAULT_LABEL_PLACEMENT, STEPPER_DEFAULT_NAVIGATION, STEPPER_DEFAULT_ORIENTATION, SlStepper, SlStepperList, SlStepperNext, SlStepperPanel, SlStepperPrevious, SlStepperStep, injectStepperDefaults, provideStepperDefaults };
+export type { StepperDefaults, StepperLabelPlacement, StepperNavigation, StepperOrientation, StepperStepReason };
+//# sourceMappingURL=slotted-angular-stepper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-stepper.d.ts","sources":["../../stepper/src/stepper.constants.ts","../../stepper/src/stepper.ts"],"mappings":";;;;;;;;AAGM,KAAM,kBAAkB,GAAG,eAAe;KACpC,qBAAqB;AACjC;AACM,KAAM,iBAAiB;AACvB,KAAM,iBAAiB;AAE7B,cAAa,2BAA2B,EAAE,kBAAiC;AAC3E,cAAa,+BAA+B,EAAE,qBAA6B;AAC3E,cAAa,0BAA0B,EAAE,iBAA4B;UAEpD,eAAe;qBACb,qBAAqB;;iBAEzB,iBAAiB;kBAChB,kBAAkB;AACjC;AAED,cAAa,sBAAsB,EAAA,cAAA,CAAA,eAAA;AAKnC;;;;;;AAMG;AACH,iBAAgB,sBAAsB,WAAW,eAAe;;;AAE/D;AAED,iBAAgB,qBAAqB,IAAI,eAAe;;ACKxD;;;;;;;;;;;;;;;;;;;AAmBG;AACH,cAmBa,SAAS;;wBAEF,aAAA,CAAA,wBAAA;;0BAEE,aAAA,CAAA,wBAAA;AACpB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,eAAA;0BACG,aAAA,CAAA,WAAA,CAAA,mBAAA,CAAA,eAAA;6BACG,aAAA,CAAA,WAAA,CAAA,qBAAA;yBACJ,aAAA,CAAA,WAAA,CAAA,iBAAA;qBACJ,aAAA,CAAA,wBAAA;2BACM,aAAA,CAAA,wBAAA;AAErB;;;;;AAKG;yBACgB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEnB;AACA;AACA;;mBAGa,aAAA,CAAA,MAAA;oBACC,aAAA,CAAA,MAAA;+BAEW,aAAA,CAAA,MAAA,CAAA,mBAAA,CAAA,eAAA;kCAGG,aAAA,CAAA,MAAA,CAAA,qBAAA;8BAGJ,aAAA,CAAA,MAAA,CAAA,iBAAA;0BAGJ,aAAA,CAAA,MAAA;;gBAEV,kBAAA,CAAA,gBAAA,CAAA,eAAA;;qBAEK,aAAA,CAAA,MAAA;;sBAGC,aAAA,CAAA,MAAA;4BACM,aAAA,CAAA,MAAA;wBACJ,aAAA,CAAA,MAAA;AAIlB,6BAAyB,aAAa;6BAIhB,mBAAA,CAAA,UAAA;;AAsBtB,oCAA+B,iBAA6B,WAAW,KAAK;kBAU/D,iBAA6B,WAAW,KAAK;sBAIzC,iBAA6B,WAAW,KAAK;AAI9D,mBAAe,KAAK;;;oDAlGT,SAAS;sDAAT,SAAS;AA6GrB;AAED;;;;;;;;AAQG;AACH,cAUa,aAAa;AACxB;AAIA;AACA;AACA;8BAEwB,aAAA,CAAA,MAAA;;qBAaP,aAAa;oDAtBnB,aAAa;sDAAb,aAAa;AAgDzB;AAED;;;;;;;AAOG;AACH,cAyFa,aAAa;sBACR,SAAA;oBAEF,aAAA,CAAA,WAAA;0BACM,aAAA,CAAA,WAAA;uBACH,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;sBACD,aAAA,CAAA,wBAAA;sBACA,aAAA,CAAA,wBAAA;mBACH,aAAA,CAAA,WAAA;;oBAGC,aAAA,CAAA,cAAA;mBACD,aAAA,CAAA,cAAA;sBAEG,aAAA,CAAA,MAAA;wBACE,aAAA,CAAA,MAAA;qBACH,aAAA,CAAA,MAAA,CAAA,mBAAA,CAAA,UAAA;0BACK,aAAA,CAAA,MAAA;AAGpB;;;;;AAKG;mBACU,aAAA,CAAA,MAAA;;wBAKK,aAAA,CAAA,MAAA;oBAmBF,KAAK;oDAnDV,aAAa;sDAAb,aAAa;AAuDzB;AAED;;;;;AAKG;AACH,cAaa,cAAc;sBACT,SAAA;mBACH,aAAA;oDAFF,cAAc;sDAAd,cAAc;AAG1B;AAED;;;;;;AAMG;AACH,cASa,aAAa;sBACR,SAAA;oDADL,aAAa;sDAAb,aAAa;AAEzB;AAED,cASa,iBAAiB;sBACZ,SAAA;oDADL,iBAAiB;sDAAjB,iBAAiB;AAE7B;;","names":[]}

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

@@ -0,0 +1,243 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, SwitchMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest, ChangeReason } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** The step the control sits at, matching the field around it. */
+type SwitchSize = 'sm' | 'md' | 'lg';
+/**
+ * What the thumb carries. `mark` draws a check when the switch is on and
+ * nothing when it is off, which is what makes the state readable beyond colour
+ * and beyond position. `none` withdraws it, and is only correct where
+ * something else carries the state.
+ */
+type SwitchIndicator = 'mark' | 'none';
+/**
+ * Which side of its label the pill sits on. `start` is the settings row every
+ * product writes: the label takes the free width and the control sits at the
+ * end of it.
+ */
+type SwitchLabelPlacement = 'end' | 'start';
+/**
+ * How long a pending switch stays silent. A save that returns in two hundred
+ * milliseconds should say nothing at all, and a live region that spoke on
+ * every toggle would make a settings page unusable with a screen reader.
+ * Primer measured the same number against the same problem.
+ *
+ * It is a constant of the family rather than an input: an application that
+ * needs longer sets a `loading` message a reader can wait for.
+ */
+declare const SWITCH_LOADING_ANNOUNCE_DELAY = 2000;
+interface SwitchDefaults {
+    indicator: SwitchIndicator;
+    labelPlacement: SwitchLabelPlacement;
+    size: SwitchSize;
+}
+declare const SWITCH_DEFAULTS: InjectionToken<SwitchDefaults>;
+/**
+ * An application decides once what its switches look like, rather than
+ * repeating the same inputs on every row of a settings page. A switch that
+ * states any of them itself still wins. What a pending switch announces comes
+ * from the language in force (`provideSlotted`).
+ *
+ * `size` is the one the field outranks: a `size="sm"` field holding an `md`
+ * control is a field and a control disagreeing about one row, so a switch
+ * inside a field takes the field's step and this token answers only outside
+ * one.
+ */
+declare function provideSwitchDefaults(defaults: Partial<SwitchDefaults>): {
+    provide: InjectionToken<SwitchDefaults>;
+    useFactory: () => SwitchDefaults;
+};
+/** What a switch renders as here, before it states anything of its own. */
+declare function injectSwitchDefaults(): SwitchDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` and
+ * `checkbox` both record: 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 SlSwitchIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSwitchIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Why the switch moved, read from the event rather than guessed. A pointer
+ * press reports a click count; Space on a checkbox reports none but is
+ * trusted; `element.click()` reports neither, and calling that `keyboard`
+ * would tell a consumer a person pressed a key nobody pressed.
+ */
+declare function activationReason(activation: {
+    detail: number;
+    isTrusted: boolean;
+}): ChangeReason;
+/**
+ * A binary setting that takes effect immediately.
+ *
+ * **The control is a checkbox with the switch role.** Space toggles it, the
+ * label names it and doubles the target, `name` and `value` are submitted,
+ * `form.reset()` restores it, and a disabled `fieldset` disables it — none of
+ * which the `button` this family shipped on before gave. ARIA 1.2 declares the
+ * `switch` role Children Presentational, so the role goes on the void `input`
+ * and never on the host: a host carrying it would fold the label and the
+ * description beside it into the control's own accessible name.
+ *
+ * **Angular pays one element and renders the control itself**, which is the
+ * shape `checkbox` settled one item earlier in this wave. `formControlName`,
+ * `ngModel`, `id` and `aria-*` sit on the host, and the label is the
+ * consumer's own content projected into a `label` that points at the control.
+ *
+ * **The click is the request.** It is the one event that fires for a pointer,
+ * for Space and for `click()`, and the one that can be refused before the
+ * element moves.
+ *
+ * **Unset means ask the field.** `disabled`, `readOnly` and `invalid` default
+ * to `undefined` rather than `false`, which is what makes "not disabled" and
+ * "said nothing" different answers.
+ */
+declare class SlSwitch implements ControlValueAccessor, OnInit {
+    /** Present means the consumer owns the state, for the life of the component. */
+    readonly checkedValue: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** What an uncontrolled switch starts from, read once. A form reset restores it. */
+    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** What this switch submits when it is on. Nothing is submitted when it is off. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<SwitchSize | undefined>;
+    readonly indicator: _angular_core.InputSignal<SwitchIndicator | undefined>;
+    readonly labelPlacement: _angular_core.InputSignal<SwitchLabelPlacement | undefined>;
+    /**
+     * The value is not settled yet. Activation is refused, the geometry does not
+     * change, and the pending label is announced politely once the wait is worth
+     * announcing.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key:
+     * `loading` is what a reader hears while the switch is pending.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<SwitchMessages> | undefined>;
+    /** Unstated rather than `false`, so the switch defers to its field. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Unstated rather than `false`. The native `readonly` attribute does nothing
+     * on a checkbox, so this is `aria-readonly` plus a refused activation.
+     */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * One output for one transition, carrying the new state, the state it
+     * replaces, the reason, the originating event and `cancel()`. There is no
+     * `[(checked)]`, because a two-way binding has one slot and can carry none of
+     * those; a form gets the same movement through `ControlValueAccessor`.
+     */
+    readonly checkedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly field;
+    private readonly defaults;
+    private readonly destroyRef;
+    private readonly writtenId;
+    private readonly writtenDescribedBy;
+    private readonly writtenRequired;
+    /** Read here so a consumer's own name survives the host binding. */
+    protected readonly writtenAriaLabel: string | null;
+    private readonly control;
+    private readonly description;
+    private readonly own;
+    private readonly announced;
+    private readonly formDisabled;
+    private onChangeFn;
+    private onTouchedFn;
+    /** A form model owns the value, so a native reset takes the model's value. */
+    private formBound;
+    /**
+     * The identifier the label points at. A consumer's own wins, then the
+     * field's: a field writes `for` at its label whether or not the control it
+     * holds draws one, so a switch that kept its own identifier inside a field
+     * would leave that label pointing at nothing.
+     */
+    readonly controlId: string;
+    /** The region the pending label is written into. */
+    readonly pendingId: string;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly resolvedSize: _angular_core.Signal<SwitchSize>;
+    readonly resolvedIndicator: _angular_core.Signal<SwitchIndicator>;
+    readonly resolvedLabelPlacement: _angular_core.Signal<SwitchLabelPlacement>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    /** The family's words in the language in force, with this switch's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<SwitchMessages>;
+    /** Merged after the consumer's own, and the pending region last. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
+    protected readonly ariaReadOnly: _angular_core.Signal<"true" | null>;
+    protected readonly ariaRequired: _angular_core.Signal<"true" | null>;
+    protected readonly ariaBusy: _angular_core.Signal<"true" | null>;
+    protected readonly disabledAttribute: _angular_core.Signal<"" | null>;
+    /** The element's own attribute, passed through and never written by the family. */
+    protected readonly requiredAttribute: _angular_core.Signal<string | null>;
+    /** Silence first, and the pending label only if the write is slow enough to notice. */
+    protected readonly announcement: _angular_core.Signal<string>;
+    constructor();
+    /**
+     * Angular creates every directive before it binds any input, so the starting
+     * state is read here rather than in the constructor: read there,
+     * `defaultChecked` is always `false` and an uncontrolled switch would start
+     * off however it was written.
+     */
+    ngOnInit(): void;
+    /** The native element, for `focus()` and anything else the platform ships. */
+    get inputElement(): HTMLInputElement;
+    /**
+     * Toggles the switch the way the platform does. The click it fires is
+     * untrusted and carries no detail, so the request reports itself as
+     * `programmatic` rather than as a key press nobody pressed.
+     */
+    toggle(): void;
+    writeValue(value: boolean | null | undefined): void;
+    registerOnChange(fn: (checked: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onClick(event: MouseEvent): void;
+    protected onBlur(): void;
+    /**
+     * Cancelling the click is what the platform offers — a checkbox reverts its
+     * own checkedness when its activation is cancelled — and the element is put
+     * back beside it, because that revert is the one part of the mechanism an
+     * environment can get wrong. A switch showing a state nobody committed is
+     * the whole defect this path exists to prevent.
+     *
+     * The restore is a microtask rather than a line here: the revert the
+     * platform does perform happens after the dispatch returns, so a value
+     * written now would be the one overwritten. It reads the state again at that
+     * point, so a consumer who accepted the move in the same tick keeps their
+     * answer.
+     */
+    private refuse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSwitch, "[slSwitch]", ["slSwitch"], { "checkedValue": { "alias": "checked"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, ["description"], ["*", "[slSwitchDescription]"], true, never>;
+}
+
+/**
+ * Help text under a switch's label.
+ *
+ * It is a directive on the consumer's own element, so a `p`, a `span` or an
+ * `inline-message` all work and none of them loses its own semantics. It
+ * carries an identifier the switch points `aria-describedby` at, which is what
+ * makes the sentence a description rather than part of the name — and it is
+ * projected outside the `label` for the same reason.
+ */
+declare class SlSwitchDescription {
+    readonly id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSwitchDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlSwitchDescription, "[slSwitchDescription]", ["slSwitchDescription"], {}, {}, never, never, true, never>;
+}
+
+export { SWITCH_DEFAULTS, SWITCH_LOADING_ANNOUNCE_DELAY, SlSwitch, SlSwitchDescription, SlSwitchIdFactory, activationReason, injectSwitchDefaults, provideSwitchDefaults };
+export type { SwitchDefaults, SwitchIndicator, SwitchLabelPlacement, SwitchSize };
+//# sourceMappingURL=slotted-angular-switch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-switch.d.ts","sources":["../../switch/src/switch-defaults.ts","../../switch/src/switch.ts","../../switch/src/switch-parts.ts"],"mappings":";;;;;;;AAEA;AACM,KAAM,UAAU;AAEtB;;;;;AAKG;KACS,eAAe;AAE3B;;;;AAIG;KACS,oBAAoB;AAEhC;;;;;;;;AAQG;AACH,cAAa,6BAA6B;UAEzB,cAAc;eAClB,eAAe;oBACV,oBAAoB;UAC9B,UAAU;AACjB;AAQD,cAAa,eAAe,EAAA,cAAA,CAAA,cAAA;AAK5B;;;;;;;;;;AAUG;AACH,iBAAgB,qBAAqB,WAAW,OAAO,CAAC,cAAc;;sBAGlD,cAAc;AAEjC;AAED;AACA,iBAAgB,oBAAoB,IAAI,cAAc;AAItD;;;;;AAKG;AACH,cACa,iBAAiB;;;oDAAjB,iBAAiB;;AAO7B;;AC9CD;;;;;AAKG;AACH,iBAAgB,gBAAgB;;;AAAmD,IAAG,YAAY;AAKlG;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACH,cAmDa,QAAS,YAAW,oBAAoB,EAAE,MAAM;;2BAEtC,aAAA,CAAA,wBAAA;;6BAKE,aAAA,CAAA,wBAAA;;oBAET,aAAA,CAAA,WAAA;mBACD,aAAA,CAAA,WAAA;mBACA,aAAA,CAAA,WAAA,CAAA,UAAA;wBACK,aAAA,CAAA,WAAA,CAAA,eAAA;6BACK,aAAA,CAAA,WAAA,CAAA,oBAAA;AACvB;;;;AAIG;sBACa,aAAA,CAAA,wBAAA;AAChB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,cAAA;;uBAEA,aAAA,CAAA,wBAAA;AAGjB;;;AAGG;uBACc,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,wBAAA;AAIhB;;;;;AAKG;4BACmB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEtB;AACA;AACA;AACA;AACA;AAGA;;AAEA;AAIA;AACA;AAEA;AACA;AACA;;;;;AAMA;;;;;AAKG;;;;sBAMa,aAAA,CAAA,MAAA;2BAEK,aAAA,CAAA,MAAA,CAAA,UAAA;gCAGK,aAAA,CAAA,MAAA,CAAA,eAAA;qCACK,aAAA,CAAA,MAAA,CAAA,oBAAA;+BAGN,aAAA,CAAA,MAAA;+BAGA,aAAA,CAAA,MAAA;8BACD,aAAA,CAAA,MAAA;;gBAEd,kBAAA,CAAA,gBAAA,CAAA,cAAA;;AAGV,oCAA8B,aAAA,CAAA,MAAA;AAS9B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,iCAA2B,aAAA,CAAA,MAAA;AAC3B,0CAAoC,aAAA,CAAA,MAAA;;AAIpC,0CAAoC,aAAA,CAAA,MAAA;;AAEpC,qCAA+B,aAAA,CAAA,MAAA;;AAe/B;;;;;AAKG;;;wBA0BiB,gBAAgB;AAIpC;;;;AAIG;;AAKH;;AASA;;AAQA,6BAAyB,UAAU;AA6BnC;AAIA;;;;;;;;;;;;AAYG;AACH;oDAxPW,QAAQ;sDAAR,QAAQ;AA+PpB;;ACxXD;;;;;;;;AAQG;AACH,cASa,mBAAmB;;oDAAnB,mBAAmB;sDAAnB,mBAAmB;AAE/B;;","names":[]}