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

package/dist/types/status-indicator/status-indicator.types.d.ts

@@ -0,0 +1,83 @@
+import type { PartialMessages, StatusIndicatorMessages } from '@slotted/core/i18n';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+/**
+ * The six operational states. The vocabulary is closed, and that is a decision
+ * rather than an omission: a seventh value would carry no tone, no glyph and
+ * no fallback word, which are the three things this family exists to supply.
+ * A product with a domain status of its own maps it onto one of these and
+ * writes its own word beside it.
+ */
+export type StatusIndicatorStatus = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'unknown';
+/** The compact mark, and the one that says the status without colour. */
+export type StatusIndicatorMark = 'dot' | 'icon';
+export type StatusIndicatorSize = 'sm' | 'md' | 'lg';
+export type StatusIndicatorLive = 'off' | 'polite' | 'assertive';
+/**
+ * What every status in an application looks like before any one of them states
+ * anything of its own. The six words come from the language in force
+ * (`SlottedProvider`).
+ */
+export interface StatusIndicatorDefaults {
+    live?: StatusIndicatorLive | undefined;
+    mark?: StatusIndicatorMark | undefined;
+    size?: StatusIndicatorSize | undefined;
+}
+export interface StatusIndicatorDefaultsProviderProps extends StatusIndicatorDefaults {
+    children?: ReactNode;
+}
+/**
+ * What `render` receives. It names the family's own attributes over the native
+ * ones every element shares; `ref` is not named because the element the
+ * consumer renders decides its own type, and React passes it through the same
+ * spread either way — the shape `badge` settled on for the same question.
+ */
+export interface StatusIndicatorRootProps extends HTMLAttributes<HTMLElement> {
+    children: ReactNode;
+    'data-mark': StatusIndicatorMark;
+    'data-part': string;
+    'data-pulse': true | undefined;
+    'data-size': StatusIndicatorSize;
+    'data-status': StatusIndicatorStatus;
+    'data-ui': string;
+}
+export interface StatusIndicatorProps extends ComponentPropsWithRef<'span'> {
+    /**
+     * The words a reader sees. They are also the accessible name: a status that
+     * shows its own words needs no second copy of them.
+     */
+    children?: ReactNode;
+    /**
+     * What a reader hears when there are no visible words. Ignored when there
+     * are, because naming an element twice is how a screen reader comes to read
+     * “Success Healthy”. Falls back to the status's word in the catalog.
+     */
+    label?: string;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * word each status is heard as when there are no visible words.
+     */
+    messages?: PartialMessages<StatusIndicatorMessages> | undefined;
+    /**
+     * Whether a change of status is announced, and how loudly. `off` by default:
+     * a status that was already on the page when it loaded is not news, and
+     * Shoelace — which makes every badge a live region — announces text nobody
+     * changed.
+     */
+    live?: StatusIndicatorLive;
+    /**
+     * `dot` is the compact mark and `icon` is the one that carries the status
+     * without colour, which is what WCAG 2.2 1.4.1 asks for wherever a product
+     * cannot spare the room for words.
+     */
+    mark?: StatusIndicatorMark;
+    /**
+     * A wave leaving the dot, for a change happening now. An icon mark does not
+     * pulse, and the wave is withdrawn under reduced motion and under forced
+     * colours, so nothing is ever said by the wave alone.
+     */
+    pulse?: boolean;
+    render?: (props: StatusIndicatorRootProps) => ReactNode;
+    size?: StatusIndicatorSize;
+    status?: StatusIndicatorStatus;
+}
+//# sourceMappingURL=status-indicator.types.d.ts.map

package/dist/types/status-indicator/status-indicator.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-indicator.types.d.ts","sourceRoot":"","sources":["../../../src/status-indicator/status-indicator.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAC/B,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEpE,yEAAyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,MAAM,CAAC;AACjD,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AACrD,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACvC,IAAI,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACvC,IAAI,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACxC;AAED,MAAM,WAAW,oCAAqC,SAAQ,uBAAuB;IACnF,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,cAAc,CAAC,WAAW,CAAC;IAC3E,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,EAAE,mBAAmB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC;IACjC,aAAa,EAAE,qBAAqB,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB,CAAC,MAAM,CAAC;IACzE;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC,uBAAuB,CAAC,GAAG,SAAS,CAAC;IAChE;;;;;OAKG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B;;;;OAIG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,SAAS,CAAC;IACxD,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,MAAM,CAAC,EAAE,qBAAqB,CAAC;CAChC"}

package/dist/types/stepper/index.d.ts

@@ -0,0 +1,6 @@
+export { Stepper, useStepper } from './stepper';
+export { StepperDefaultsProvider, useStepperDefaults } from './stepper-defaults';
+export { StepperList, StepperNext, StepperPanel, StepperPrevious, StepperStep, } from './stepper-parts';
+export type { StepperAdvanceProps } from './stepper-parts';
+export type { StepperChangeRequest, StepperContextValue, StepperDefaults, StepperDefaultsProviderProps, StepperLabelPlacement, StepperListProps, StepperListRootProps, StepperNavigation, StepperOrientation, StepperPanelProps, StepperPanelRootProps, StepperProps, StepperRootProps, StepperStepProps, StepperStepReason, StepperStepRootProps, StepStatus, } from './stepper.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/stepper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/stepper/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EACL,WAAW,EACX,WAAW,EACX,YAAY,EACZ,eAAe,EACf,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EACV,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,4BAA4B,EAC5B,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,UAAU,GACX,MAAM,iBAAiB,CAAC"}

package/dist/types/stepper/stepper-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { StepperDefaults, StepperDefaultsProviderProps } from './stepper.types';
+export declare function useStepperDefaults(): 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 prop is
+ * never overridden by context. Its words come from the language in force
+ * (`SlottedProvider`).
+ */
+export declare function StepperDefaultsProvider({ children, ...defaults }: StepperDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=stepper-defaults.d.ts.map

package/dist/types/stepper/stepper-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper-defaults.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAIrF,wBAAgB,kBAAkB,IAAI,eAAe,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,4BAA4B,+BAe9F"}

package/dist/types/stepper/stepper-parts.d.ts

@@ -0,0 +1,54 @@
+import { type ReactNode } from 'react';
+import type { StepperListProps, StepperPanelProps, StepperStepProps } from './stepper.types';
+/**
+ * The ordered list, and the one part that knows how many steps there are.
+ *
+ * It maps its children for two facts a step cannot know about itself: its own
+ * index, and whether it is the last — the last draws no connector, because
+ * there is nothing after it.
+ *
+ * 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.
+ */
+export declare function StepperList({ children, ref, render, onKeyDown, ...nativeProps }: StepperListProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * One step: its marker, its name, the second line under it, and the connector
+ * that runs to the next one.
+ *
+ * The header is a `button`, an `a` or a `span`, depending on what the flow lets
+ * the reader do — and `none` is the read-only progress indicator the field
+ * ships as a component of its own.
+ *
+ * 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.
+ */
+export declare function StepperStep({ children, complete, description, disabled, href, invalid, label, loading, marker, ref, render, ...nativeProps }: StepperStepProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * 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.
+ */
+export declare function StepperPanel({ children, ref, render, ...nativeProps }: StepperPanelProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+export type StepperAdvanceProps = {
+    children?: ReactNode;
+    disabled?: boolean;
+    onClick?: ((event: never) => void) | undefined;
+    render: (props: {
+        disabled: boolean;
+        onClick: (event: never) => void;
+    }) => ReactNode;
+};
+/**
+ * The one shape in which this family will hand a consumer an advance handler
+ * without also handing them a button. `render` receives the handler and whether
+ * the move is available; the element, its variant and its label stay the
+ * consumer's, and `useStepper()` is the shorter way to the same thing.
+ */
+export declare function StepperNext({ disabled, onClick, render }: StepperAdvanceProps): ReactNode;
+export declare function StepperPrevious({ disabled, onClick, render }: StepperAdvanceProps): ReactNode;
+//# sourceMappingURL=stepper-parts.d.ts.map

package/dist/types/stepper/stepper-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper-parts.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper-parts.tsx"],"names":[],"mappings":"AACA,OAAO,EAA2D,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAUhG,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EAEjB,gBAAgB,EAEjB,MAAM,iBAAiB,CAAC;AAezB;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,GAAG,EACH,MAAM,EACN,SAAS,EACT,GAAG,WAAW,EACf,EAAE,gBAAgB,+TA+DlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,KAAK,EACL,OAAO,EACP,MAAM,EACN,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,gBAAgB,+TAsHlB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+TAkBxF;AAWD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC/C,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;KAAE,KAAK,SAAS,CAAC;CACtF,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,mBAAmB,aAM7E;AAED,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,mBAAmB,aAMjF"}

package/dist/types/stepper/stepper.d.ts

@@ -0,0 +1,50 @@
+
+
+import type { StepperContextValue, StepperProps, StepperStepContextValue } from './stepper.types';
+/**
+ * What the stepper around this part says, and the imperative surface a consumer
+ * cannot express as a prop.
+ *
+ * It is also how a flow advances: moving one step is a handler on the
+ * consumer's own button, not a button this family paints. Angular Material
+ * reaches the same conclusion with `matStepperNext`, a directive placed on a
+ * `mat-button` — a family that shipped its own advance button would ship a
+ * second button nobody could theme with the first.
+ */
+export declare function useStepper(): StepperContextValue;
+export declare function useStepperStep(): StepperStepContextValue | undefined;
+export declare const StepperStepProvider: import("react").Provider<StepperStepContextValue | undefined>;
+/** The registry each `Stepper.Step` writes itself into, so the root can count. */
+export interface StepperRegistration {
+    complete: boolean | undefined;
+    disabled: boolean | undefined;
+}
+/**
+ * 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,
+ * because `request.cancel()` says the same thing at the same moment.
+ *
+ * **It never claims completion.** `complete` is the consumer's fact about a
+ * step; `autoComplete` is the shorthand for the flow where reaching step three
+ * does mean the first two are done, and it is off.
+ */
+export declare function Stepper({ autoComplete, children, defaultStep, labelPlacement, linear, messages, navigation, onStepChange, orientation, render, step, ...nativeProps }: StepperProps): import("react").JSX.Element;
+/**
+ * What the list hands back to the root. The registry is a setter rather than a
+ * context value, because the list is what actually sees the steps and the root
+ * is what has to count them.
+ */
+export declare const StepperRegistry: import("react").Context<((steps: readonly StepperRegistration[]) => void) | undefined>;
+//# sourceMappingURL=stepper.d.ts.map

package/dist/types/stepper/stepper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper.tsx"],"names":[],"mappings":"AAAA,OAAO,qCAAqC,CAAC;AAC7C,OAAO,qDAAqD,CAAC;AAS7D,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EAEZ,uBAAuB,EAExB,MAAM,iBAAiB,CAAC;AAKzB;;;;;;;;;GASG;AACH,wBAAgB,UAAU,IAAI,mBAAmB,CAMhD;AAED,wBAAgB,cAAc,IAAI,uBAAuB,GAAG,SAAS,CAEpE;AAED,eAAO,MAAM,mBAAmB,+DAA8B,CAAC;AAE/D,kFAAkF;AAClF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,EACtB,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,cAAc,EACd,MAAM,EACN,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,WAAW,EACX,MAAM,EACN,IAAI,EACJ,GAAG,WAAW,EACf,EAAE,YAAY,+BAkFd;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,mCACjB,SAAS,mBAAmB,EAAE,KAAK,IAAI,cACtC,CAAC"}

package/dist/types/stepper/stepper.types.d.ts

@@ -0,0 +1,133 @@
+import type { FamilyTranslator, PartialMessages, StepperMessages } from '@slotted/core/i18n';
+import type { ChangeRequest } from '@slotted/core/state';
+import type { StepOrientation, StepStatus } from '@slotted/core/steps';
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+export type StepperOrientation = StepOrientation;
+export type StepperLabelPlacement = 'end' | 'bottom';
+/** What a step header is: a control, a destination, or neither. */
+export type StepperNavigation = 'button' | 'link' | 'none';
+export type StepperStepReason = 'pointer' | 'keyboard' | 'programmatic';
+export type StepperChangeRequest = ChangeRequest<number>;
+export type { StepStatus };
+export interface StepperDefaults {
+    labelPlacement?: StepperLabelPlacement | undefined;
+    linear?: boolean | undefined;
+    navigation?: StepperNavigation | undefined;
+    orientation?: StepperOrientation | undefined;
+}
+export interface StepperDefaultsProviderProps extends StepperDefaults {
+    children?: ReactNode;
+}
+export interface StepperRootProps extends ComponentPropsWithRef<'div'> {
+    'data-label-placement': StepperLabelPlacement;
+    'data-navigation': StepperNavigation;
+    'data-orientation': StepperOrientation;
+    'data-part': string;
+    'data-ui': string;
+}
+export interface StepperProps extends ComponentPropsWithRef<'div'> {
+    /**
+     * Whether reaching a later step means the earlier ones are finished. Off,
+     * because walking past a step is not the same as completing it, and a family
+     * that assumed otherwise would report work as done that never was.
+     */
+    autoComplete?: boolean | undefined;
+    /** The step an uncontrolled stepper starts from, read once. */
+    defaultStep?: number | undefined;
+    /** `end` beside the marker, `bottom` under it. */
+    labelPlacement?: StepperLabelPlacement | undefined;
+    /** Requires every earlier step to be complete before a later one is reached. */
+    linear?: boolean | undefined;
+    /**
+     * 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.
+     */
+    messages?: PartialMessages<StepperMessages> | undefined;
+    /** What a header is. `none` is a read-only progress indicator. */
+    navigation?: StepperNavigation | undefined;
+    /** Called before the step moves, with the request that carries the reason. */
+    onStepChange?: ((step: number, request: StepperChangeRequest) => void) | undefined;
+    orientation?: StepperOrientation | undefined;
+    render?: ((props: StepperRootProps) => ReactNode) | undefined;
+    /** Present means controlled, for the life of the component. */
+    step?: number | undefined;
+}
+export interface StepperListProps extends ComponentPropsWithRef<'ol'> {
+    render?: ((props: StepperListRootProps) => ReactNode) | undefined;
+}
+export interface StepperListRootProps extends ComponentPropsWithRef<'ol'> {
+    'data-part': string;
+}
+export interface StepperStepRootProps extends ComponentPropsWithRef<'li'> {
+    'data-complete': '' | undefined;
+    'data-current': '' | undefined;
+    'data-disabled': '' | undefined;
+    'data-invalid': '' | undefined;
+    'data-loading': '' | undefined;
+    'data-part': string;
+}
+export interface StepperStepProps extends Omit<ComponentPropsWithRef<'li'>, 'children'> {
+    children?: ReactNode;
+    /** Whether the consumer says the work on this step is done. */
+    complete?: boolean | undefined;
+    /** The second line under the step's name. */
+    description?: ReactNode | undefined;
+    /** Takes the header out of reach, in a linear flow or outside one. */
+    disabled?: boolean | undefined;
+    /** The destination, when `navigation="link"`. */
+    href?: string | undefined;
+    /** Whether the work on this step failed. Outranks `complete`. */
+    invalid?: boolean | undefined;
+    /** The step's name. */
+    label?: ReactNode | undefined;
+    /** Whether this step is waiting on something; the header stops answering. */
+    loading?: boolean | undefined;
+    /** What the marker shows in place of the index. */
+    marker?: ReactNode | undefined;
+    render?: ((props: StepperStepRootProps) => ReactNode) | undefined;
+}
+export interface StepperPanelProps extends ComponentPropsWithRef<'div'> {
+    render?: ((props: StepperPanelRootProps) => ReactNode) | undefined;
+}
+export interface StepperPanelRootProps extends ComponentPropsWithRef<'div'> {
+    'data-part': string;
+    role: 'group';
+}
+/** What the stepper tells the parts inside it, and what `useStepper` returns. */
+export interface StepperContextValue {
+    canGoNext: boolean;
+    canGoPrevious: boolean;
+    count: number;
+    /** The status one index is in, from `@slotted/core/steps`. */
+    statusOf: (index: number) => StepStatus;
+    goToStep: (step: number, reason?: StepperStepReason, source?: unknown) => void;
+    ids: {
+        panel: (index: number) => string;
+        trigger: (index: number) => string;
+    };
+    labelPlacement: StepperLabelPlacement;
+    linear: boolean;
+    /** The locale in force: what the descriptors a step announces are listed in. */
+    locale: string;
+    navigation: StepperNavigation;
+    next: (reason?: StepperStepReason, source?: unknown) => void;
+    orientation: StepperOrientation;
+    /** How far along the row the reader has travelled, nought to a hundred. */
+    percent: number;
+    previous: (reason?: StepperStepReason, source?: unknown) => void;
+    /** Back to the step the stepper started from. */
+    reset: (source?: unknown) => void;
+    step: number;
+    /** Whether a linear flow lets the reader jump to an index. */
+    reachable: (index: number) => boolean;
+    /** The family's words in the language in force, with this stepper's `messages` laid over them. */
+    t: FamilyTranslator<StepperMessages>;
+}
+/** What one step is told by the list that laid it out. */
+export interface StepperStepContextValue {
+    index: number;
+    last: boolean;
+    /** Whether the reader has walked past the connector after this step. */
+    travelled: boolean;
+}
+//# sourceMappingURL=stepper.types.d.ts.map

package/dist/types/stepper/stepper.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper.types.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper.types.ts"],"names":[],"mappings":"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"}

package/dist/types/switch/index.d.ts

@@ -0,0 +1,4 @@
+export { Switch } from './switch';
+export { SWITCH_LOADING_ANNOUNCE_DELAY, SwitchDefaultsProvider, useSwitchDefaults, } from './switch-defaults';
+export type { SwitchCheckedReason, SwitchDefaults, SwitchDefaultsProviderProps, SwitchIndicator, SwitchLabelPlacement, SwitchProps, SwitchRootProps, SwitchSize, } from './switch.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/switch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/switch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,6BAA6B,EAC7B,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,2BAA2B,EAC3B,eAAe,EACf,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,gBAAgB,CAAC"}

package/dist/types/switch/switch-defaults.d.ts

@@ -0,0 +1,27 @@
+import type { SwitchDefaults, SwitchDefaultsProviderProps } from './switch.types';
+/**
+ * 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 a prop: an application that needs
+ * longer sets a `loading` message a reader can wait for.
+ */
+export declare const SWITCH_LOADING_ANNOUNCE_DELAY = 2000;
+/** What a switch renders as here, before it states anything of its own. */
+export declare function useSwitchDefaults(): SwitchDefaults;
+/**
+ * An application decides once what its switches look like, rather than
+ * repeating the same props 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 (`SlottedProvider`).
+ *
+ * `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 provider answers only outside
+ * one. Among the surveyed implementations only Angular Material and Mantine
+ * ship application-wide defaults, and neither ships them for two frameworks.
+ */
+export declare function SwitchDefaultsProvider({ children, ...defaults }: SwitchDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=switch-defaults.d.ts.map

package/dist/types/switch/switch-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-defaults.d.ts","sourceRoot":"","sources":["../../../src/switch/switch-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAElF;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAUlD,2EAA2E;AAC3E,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,2BAA2B,+BAc5F"}

package/dist/types/switch/switch-demo.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+/**
+ * One demonstration: what it is called, what to look at, and the stage that
+ * owns the distance between the examples on it. Every story composes this
+ * rather than laying itself out, so no two examples can end up against each
+ * other and no story reaches for an inline style.
+ */
+export declare function Scene({ children, label, layout, note, }: {
+    children: ReactNode;
+    label: string;
+    layout?: 'block' | 'row' | 'stack' | 'prose';
+    note: ReactNode;
+}): import("react").JSX.Element;
+export declare function Grid({ children, columns }: {
+    children: ReactNode;
+    columns: 1 | 2 | 3;
+}): import("react").JSX.Element;
+/** A narrow column, for showing what a control does below 320 pixels. */
+export declare function Measure({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=switch-demo.d.ts.map

package/dist/types/switch/switch-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-demo.d.ts","sourceRoot":"","sources":["../../../src/switch/switch-demo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,EACpB,QAAQ,EACR,KAAK,EACL,MAAgB,EAChB,IAAI,GACL,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;IAC7C,IAAI,EAAE,SAAS,CAAC;CACjB,+BAYA;AAED,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;CAAE,+BAMtF;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAE5D"}

package/dist/types/switch/switch.d.ts

@@ -0,0 +1,48 @@
+
+import type { ChangeReason } from '@slotted/core/state';
+import type { ReactNode } from 'react';
+import type { SwitchProps } from './switch.types';
+/**
+ * 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.
+ *
+ * It takes the two facts rather than the event, and it is exported for the
+ * test: `isTrusted` is a read-only property no test can forge, so the trusted
+ * half of the rule is unreachable through a dispatched event.
+ */
+export 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, a
+ * `<label for>` names it and doubles the target, `name` and `value` are
+ * submitted, `form.reset()` restores it, and a disabled `fieldset` disables it
+ * — none of which a `button` gives, and all of which the family that shipped
+ * before this one had to do without. ARIA 1.2 declares the `switch` role
+ * Children Presentational, so the role goes on the void `input` and never on
+ * the root: a root carrying it would fold the label and the description beside
+ * it into the control's own accessible name.
+ *
+ * **The label is the control's own.** It points at the control through `for`,
+ * so it names the switch and doubles its target, and the description under it
+ * sits outside the label — inside, it would join the accessible name. The
+ * anatomy is `checkbox`'s, down to the metrics, because two binary controls in
+ * one list have to line up.
+ *
+ * **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. A consumer who owns the value, a cancelled request, a
+ * read-only control and a pending one all refuse it the same way, so the DOM
+ * never shows a state nobody asked for.
+ *
+ * **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.
+ */
+export declare function Switch({ 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, 'aria-readonly': ariaReadOnly, 'aria-required': ariaRequired, checked, children, className, defaultChecked, description, disabled, id, indicator, invalid, labelPlacement, loading, messages, onChange, onCheckedChange, onClick, readOnly, ref, render, size, style, ...nativeProps }: SwitchProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=switch.d.ts.map

package/dist/types/switch/switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../../../src/switch/switch.tsx"],"names":[],"mappings":"AAAA,OAAO,mCAAmC,CAAC;AAI3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAA2B,SAAS,EAAE,MAAM,OAAO,CAAC;AAOhE,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,gBAAgB,CAAC;AAEnE;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,YAAY,CAGjG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,EACrB,kBAAkB,EAAE,WAAW,EAC/B,cAAc,EAAE,WAAW,EAC3B,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,YAAY,EAC7B,OAAO,EACP,QAAQ,EACR,SAAS,EACT,cAAsB,EACtB,WAAW,EACX,QAAQ,EACR,EAAE,EACF,SAAS,EACT,OAAO,EACP,cAAc,EACd,OAAe,EACf,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,OAAO,EACP,QAAQ,EACR,GAAG,EACH,MAAM,EACN,IAAI,EACJ,KAAK,EACL,GAAG,WAAW,EACf,EAAE,WAAW,+TA8Mb"}

package/dist/types/switch/switch.types.d.ts

@@ -0,0 +1,118 @@
+import type { PartialMessages, SwitchMessages } from '@slotted/core/i18n';
+import type { ChangeRequest } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+/** The step the control sits at, matching the field around it. */
+export 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 the
+ * status word carries that instead.
+ */
+export 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.
+ */
+export type SwitchLabelPlacement = 'end' | 'start';
+/**
+ * Why the switch moved. A pointer press reports a click count; Space reports
+ * none but is trusted; `element.click()` reports neither.
+ */
+export type SwitchCheckedReason = Extract<ChangeRequest<boolean>['reason'], 'pointer' | 'keyboard' | 'programmatic'>;
+/** What an application sets once for every switch under it. */
+export interface SwitchDefaults {
+    indicator: SwitchIndicator;
+    labelPlacement: SwitchLabelPlacement;
+    size: SwitchSize;
+}
+export interface SwitchDefaultsProviderProps extends Partial<SwitchDefaults> {
+    children?: ReactNode | undefined;
+}
+/**
+ * What `render` receives for the root. Written against
+ * `HTMLAttributes<HTMLElement>` so it can be spread onto any element, which is
+ * what makes the substitution real.
+ */
+export interface SwitchRootProps extends HTMLAttributes<HTMLElement> {
+    'data-checked'?: '' | undefined;
+    'data-disabled'?: '' | undefined;
+    'data-indicator': SwitchIndicator;
+    'data-invalid'?: '' | undefined;
+    'data-label-placement': SwitchLabelPlacement;
+    'data-loading'?: '' | undefined;
+    'data-part': string;
+    'data-readonly'?: '' | undefined;
+    'data-size': SwitchSize;
+    'data-ui': string;
+}
+/**
+ * `size` is omitted and redeclared: on an `input` it is the visible character
+ * count, and this family's axis is a control step. `checked` and
+ * `defaultChecked` are redeclared so the state model owns them, and `type` and
+ * `role` are withheld — a switch that is not a checkbox with the switch role
+ * is a different component.
+ *
+ * Everything else is the element's, and it reaches the element: `name`,
+ * `value`, `form`, `required`, `autoFocus`, `tabIndex`, every `aria-*` and
+ * every handler. `className` and `style` are the exception, and they reach the
+ * root, because the root is what a consumer sees.
+ */
+export interface SwitchProps extends Omit<ComponentPropsWithRef<'input'>, 'checked' | 'defaultChecked' | 'role' | 'size' | 'type'> {
+    /** Present means controlled, for the life of the component. */
+    checked?: boolean | undefined;
+    /**
+     * The label, beside the pill. It is a real `label` pointing at the control
+     * through `for`, so it names the switch and doubles its target — and a
+     * switch written without one takes `aria-label` or the field's label instead.
+     */
+    children?: ReactNode | undefined;
+    /** What an uncontrolled switch starts from, read once. A native form reset restores it. */
+    defaultChecked?: boolean | undefined;
+    /**
+     * Unstated rather than `false`, so the control defers to the field around
+     * it. Stated, it wins, and it is the native attribute: out of the tab order
+     * and out of submission.
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Help text under the label. It is never inside the label — inside, it would
+     * join the accessible name, and help text that toggles a setting when it is
+     * clicked is help text nobody reads — and it reaches the control through
+     * `aria-describedby`.
+     */
+    description?: ReactNode | undefined;
+    /** What the thumb carries. Defaults to the provider, then to `mark`. */
+    indicator?: SwitchIndicator | undefined;
+    /**
+     * Unstated rather than `false`. Writes `aria-invalid` on the control and
+     * `data-invalid` on the root.
+     */
+    invalid?: boolean | undefined;
+    /** Which side of the label the pill sits on. Defaults to the provider, then to `end`. */
+    labelPlacement?: SwitchLabelPlacement | undefined;
+    /**
+     * The value is not settled yet. Activation is refused, the geometry does not
+     * change, and the pending label is announced politely after two seconds.
+     */
+    loading?: boolean | undefined;
+    /**
+     * Words laid over the catalog of the language in force, key by key:
+     * `loading` is what a reader hears while the switch is pending.
+     */
+    messages?: PartialMessages<SwitchMessages> | undefined;
+    /** Called before the switch moves, with the request that carries the reason. */
+    onCheckedChange?: ((checked: boolean, request: ChangeRequest<boolean>) => void) | undefined;
+    /**
+     * Unstated rather than `false`. The native `readonly` attribute does nothing
+     * on a checkbox, so this is `aria-readonly` plus a refused activation: the
+     * control stays focusable, announced and submitted.
+     */
+    readOnly?: boolean | undefined;
+    /** Renders the root into another element. */
+    render?: ((props: SwitchRootProps) => ReactNode) | undefined;
+    /** Defaults to the field, then to the provider, then to `md`. */
+    size?: SwitchSize | undefined;
+}
+//# sourceMappingURL=switch.types.d.ts.map

package/dist/types/switch/switch.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.types.d.ts","sourceRoot":"","sources":["../../../src/switch/switch.types.ts"],"names":[],"mappings":"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"}