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

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

@@ -0,0 +1,390 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { FamilyTranslator, ButtonMessages, PartialMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, AfterViewInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/**
+ * The five colours are tones in `docs/token-foundation.md`, so the axis that
+ * selects one is `tone`. `variant` names what it actually selects: how the
+ * chosen tone is painted.
+ */
+declare const BUTTON_TONES: readonly ["accent", "secondary", "success", "warning", "danger"];
+declare const BUTTON_VARIANTS: readonly ["solid", "outline", "ghost"];
+declare const BUTTON_SIZES: readonly ["sm", "md", "lg"];
+declare const BUTTON_SHAPES: readonly ["square", "circle"];
+type ButtonTone = (typeof BUTTON_TONES)[number];
+type ButtonVariant = (typeof BUTTON_VARIANTS)[number];
+type ButtonSize = (typeof BUTTON_SIZES)[number];
+type ButtonShape = (typeof BUTTON_SHAPES)[number];
+type ButtonType = 'button' | 'submit' | 'reset';
+
+/** A state attribute is present or absent; it never carries a value. */
+declare function stateAttribute(active: boolean): "" | null;
+declare function blockActivation(event: Event): void;
+interface InertInputs {
+    disabled: Signal<boolean>;
+    focusableWhenDisabled: Signal<boolean>;
+    loading: Signal<boolean>;
+}
+/**
+ * Being unavailable and being unreachable are two decisions the platform only
+ * offers together. `disabled` takes the control out of the tab sequence, which
+ * takes its tooltip and its explanation with it; `aria-disabled` announces the
+ * same thing and leaves it reachable, at the price of a refusal the family has
+ * to enforce itself.
+ *
+ * A waiting control is always the second kind. React Aria's pending button and
+ * Primer's loading button agree: focus must survive an action the person just
+ * started, or the keyboard lands somewhere else mid-task.
+ */
+declare function resolveInertness(inputs: InertInputs): {
+    refuses: Signal<boolean>;
+    nativelyDisabled: Signal<boolean>;
+    ariaDisabled: Signal<"true" | null>;
+};
+/**
+ * Whether the ring is drawn yet. The wait itself starts at once — the
+ * activation is refused from the first millisecond — but a spinner shown for
+ * ninety of them is a flash rather than a status, so the picture can lag the
+ * state by as long as the consumer says.
+ */
+declare function resolveLoadingIndicator(loading: Signal<boolean>, loadingDelay: Signal<number>): Signal<boolean>;
+/**
+ * What the member is waiting for, published to the visual slots it projects.
+ * A slot is written by the consumer on the consumer's own element, so the
+ * button cannot reach into it: it tells the slot instead, and the slot draws
+ * the ring over the glyph it holds.
+ */
+interface ButtonWait {
+    readonly waiting: Signal<boolean>;
+    /** The family's words in the language in force; the ring is named by `loading`. */
+    readonly t: FamilyTranslator<ButtonMessages>;
+    /**
+     * Whether the control has a start slot. The ring takes the first visual slot
+     * the control has, and the two slots are siblings — a sibling cannot be
+     * injected — so the member that owns both answers for them.
+     */
+    readonly hasStart: Signal<boolean>;
+}
+declare const BUTTON_WAIT: InjectionToken<ButtonWait>;
+/**
+ * Markers rather than wrappers. The part attribute lands on the element the
+ * consumer already wrote, so an absent icon leaves no empty box behind and the
+ * rendered tree matches the React binding's exactly.
+ *
+ * They are components rather than directives because a slot has one thing to
+ * render of its own: the ring that stands in for its glyph while the control
+ * waits. The glyph is projected under it and fades; it is not taken out, both
+ * because Angular cannot take back content the consumer projected and because
+ * an element that leaves the flow can move what is beside it.
+ */
+declare class SlButtonStart {
+    protected readonly wait: ButtonWait | null;
+    protected readonly drawsRing: Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlButtonStart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlButtonStart, "[slButtonStart]", ["slButtonStart"], {}, {}, never, ["*"], true, never>;
+}
+declare class SlButtonEnd {
+    protected readonly wait: ButtonWait | null;
+    /**
+     * The ring takes the first visual slot the control has, so an end slot draws
+     * it only when there is no start slot to take it.
+     */
+    protected readonly drawsRing: Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlButtonEnd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlButtonEnd, "[slButtonEnd]", ["slButtonEnd"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A momentary action. Persistent state belongs to SlToggleButton, and
+ * navigation to SlButtonLink, so this member never grows an `aria-pressed` or
+ * an `href`.
+ *
+ * There is no `render` input, and there is no need for one: the component is a
+ * directive on the element the consumer wrote, so substituting the element is
+ * something the consumer does by writing a different one.
+ */
+declare class SlButton implements ButtonWait {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Keeps an unavailable control in the tab sequence, announcing
+     * `aria-disabled` instead of carrying the attribute that removes it. The
+     * activation is refused either way.
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** How long the wait lasts before the ring is drawn. The refusal is immediate. */
+    readonly loadingDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: what the
+     * ring announces itself as (`loading`). It is a progress bar, so it has a name.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ButtonMessages> | undefined>;
+    /** The family's words in the language in force, with this button's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ButtonMessages>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly tone: _angular_core.InputSignal<"accent" | "secondary" | "success" | "warning" | "danger" | undefined>;
+    readonly type: _angular_core.InputSignal<ButtonType>;
+    readonly variant: _angular_core.InputSignal<"solid" | "outline" | "ghost" | undefined>;
+    readonly stateAttribute: typeof stateAttribute;
+    protected readonly appearance: {
+        size: _angular_core.Signal<"sm" | "md" | "lg">;
+        tone: _angular_core.Signal<"accent" | "secondary" | "success" | "warning" | "danger">;
+        variant: _angular_core.Signal<"solid" | "outline" | "ghost">;
+    };
+    protected readonly inert: {
+        refuses: _angular_core.Signal<boolean>;
+        nativelyDisabled: _angular_core.Signal<boolean>;
+        ariaDisabled: _angular_core.Signal<"true" | null>;
+    };
+    readonly waiting: _angular_core.Signal<boolean>;
+    private readonly start;
+    private readonly end;
+    readonly hasStart: _angular_core.Signal<boolean>;
+    /**
+     * A control with a visual slot gives the ring that box, and the slot draws
+     * it. Only a control with neither draws one of its own, centred over the
+     * label the stylesheet then fades.
+     */
+    protected readonly hasVisualSlot: _angular_core.Signal<boolean>;
+    /**
+     * The capture phase, because a control that is unavailable or still working
+     * must refuse the activation before any listener the consumer attached to it
+     * can run — including the submit a `type="submit"` button would perform while
+     * it keeps its place in the tab sequence.
+     */
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlButton, "button[slButton]", ["slButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, ["start", "end"], ["[slButtonStart]", "*", "[slButtonEnd]"], true, never>;
+}
+
+/**
+ * Navigation wearing the action surface. The element is an `a`, so activation,
+ * the context menu and every modified click stay the platform's, and Space
+ * does not activate it because Space does not activate a link. `routerLink`
+ * works on it for the same reason: the component is a directive on the
+ * consumer's own anchor.
+ *
+ * A disabled link keeps no `href`. An anchor that keeps its destination and
+ * only blocks `click` still navigates on a middle click and on a modified
+ * click; taking the destination away is what actually disables it. It stays in
+ * the tab sequence with `role="link"` and `aria-disabled`, because a control a
+ * keyboard user cannot reach is one they cannot discover is unavailable.
+ */
+declare class SlButtonLink {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly tone: _angular_core.InputSignal<"accent" | "secondary" | "success" | "warning" | "danger" | undefined>;
+    readonly variant: _angular_core.InputSignal<"solid" | "outline" | "ghost" | undefined>;
+    /**
+     * The destination, when the anchor is not driven by a router. A `routerLink`
+     * on the same element writes the `href` itself, and this input stays unset.
+     */
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    readonly stateAttribute: typeof stateAttribute;
+    protected readonly appearance: {
+        size: _angular_core.Signal<"sm" | "md" | "lg">;
+        tone: _angular_core.Signal<"accent" | "secondary" | "success" | "warning" | "danger">;
+        variant: _angular_core.Signal<"solid" | "outline" | "ghost">;
+    };
+    /**
+     * A disabled link keeps its place in the tab sequence: without an `href` the
+     * anchor would drop out of it, so the zero is stated rather than inherited.
+     */
+    readonly tabIndex: _angular_core.Signal<0 | null>;
+    constructor();
+    private refuse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlButtonLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlButtonLink, "a[slButtonLink]", ["slButtonLink"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; }, {}, never, ["[slButtonStart]", "*", "[slButtonEnd]"], true, never>;
+}
+
+/**
+ * What a button paints itself as here, before it states anything of its own.
+ *
+ * Every axis is optional, and that is the difference from a family with one
+ * member. The four members disagree about their own defaults on purpose — a
+ * primary action is accent and solid, an icon button is neutral and ghost — so
+ * a token that filled every axis would flatten them into one appearance the
+ * moment an application set a single value.
+ */
+interface ButtonDefaults {
+    /**
+     * Absence is written explicitly rather than left to the optional marker.
+     * Under `exactOptionalPropertyTypes` the two are not interchangeable, and an
+     * unset axis has to be expressible by a value as well as by a missing key —
+     * a provider that computes its defaults cannot omit a property.
+     */
+    size?: ButtonSize | undefined;
+    tone?: ButtonTone | undefined;
+    variant?: ButtonVariant | undefined;
+}
+declare const BUTTON_DEFAULTS_TOKEN: InjectionToken<ButtonDefaults>;
+/**
+ * An application decides once how its actions are painted and how large they
+ * are, rather than repeating three inputs on every button. A button that states
+ * an axis itself still wins: an explicit input is never overridden by the
+ * token.
+ */
+declare function provideButtonDefaults(defaults: ButtonDefaults): {
+    provide: InjectionToken<ButtonDefaults>;
+    useValue: ButtonDefaults;
+};
+declare function injectButtonDefaults(): ButtonDefaults;
+
+/**
+ * The same control as SlButton with no room for a label, so the accessible
+ * name is an explicit attribute, checked in development because an attribute
+ * cannot be made mandatory by a template.
+ *
+ * It takes `pressed` directly instead of being paired with a toggle component
+ * of its own: its name is already an attribute that must not change with the
+ * state, so toggling adds no obligation a separate component would exist to
+ * enforce. `aria-pressed` appears only once the consumer opts in.
+ *
+ * The glyph's own box holds the ring while the control waits: it is already
+ * the size of the ring, so nothing moves, and the glyph is the one thing this
+ * member can afford to hide, because it carries no name.
+ */
+declare class SlIconButton implements AfterViewInit {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: what the
+     * ring announces itself as (`loading`). It is a progress bar, so it has a name.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ButtonMessages> | undefined>;
+    /** The family's words in the language in force, with this button's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ButtonMessages>;
+    readonly shape: _angular_core.InputSignal<"square" | "circle">;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly tone: _angular_core.InputSignal<"accent" | "secondary" | "success" | "warning" | "danger" | undefined>;
+    readonly type: _angular_core.InputSignal<ButtonType>;
+    readonly variant: _angular_core.InputSignal<"solid" | "outline" | "ghost" | undefined>;
+    /** Present means controlled, for the life of the component. */
+    readonly pressed: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly defaultPressed: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * 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 can carry none of those.
+     */
+    readonly pressedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly stateAttribute: typeof stateAttribute;
+    protected readonly appearance: {
+        size: _angular_core.Signal<"sm" | "md" | "lg">;
+        tone: _angular_core.Signal<"accent" | "secondary" | "success" | "warning" | "danger">;
+        variant: _angular_core.Signal<"solid" | "outline" | "ghost">;
+    };
+    protected readonly inert: {
+        refuses: _angular_core.Signal<boolean>;
+        nativelyDisabled: _angular_core.Signal<boolean>;
+        ariaDisabled: _angular_core.Signal<"true" | null>;
+    };
+    readonly waiting: _angular_core.Signal<boolean>;
+    private readonly state;
+    readonly isPressed: _angular_core.Signal<boolean>;
+    /**
+     * Whether the consumer opted into the toggle capability at all. Passing
+     * either half of the state model is the opt-in, in both bindings: an icon
+     * button that announced `aria-pressed` without one would be announcing a
+     * state it does not have.
+     */
+    readonly toggles: _angular_core.Signal<boolean>;
+    private readonly element;
+    private readonly destroyRef;
+    /**
+     * The capture phase, because a control that is unavailable or still working
+     * must refuse the activation before any listener the consumer attached to it
+     * can run.
+     */
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlIconButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlIconButton, "button[slIconButton]", ["slIconButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "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, ["*"], true, never>;
+}
+
+/**
+ * A two-state action. The APG is explicit that the label of a toggle must not
+ * change with its state — "Mute" stays "Mute" and the state is announced
+ * beside it — so this is a component of its own rather than an input on
+ * SlButton: reaching for it is what makes that obligation visible.
+ *
+ * It waits, because a toggle that persists is the common one: "Follow",
+ * "Subscribe" and "Watch" all reach a server before the state is true. While
+ * it waits it holds the state it still has, so the person is never shown a
+ * value that has not been agreed to.
+ */
+declare class SlToggleButton implements AfterViewInit, ButtonWait {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: what the
+     * ring announces itself as (`loading`). It is a progress bar, so it has a name.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ButtonMessages> | undefined>;
+    /** The family's words in the language in force, with this button's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ButtonMessages>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly tone: _angular_core.InputSignal<"accent" | "secondary" | "success" | "warning" | "danger" | undefined>;
+    readonly type: _angular_core.InputSignal<ButtonType>;
+    readonly variant: _angular_core.InputSignal<"solid" | "outline" | "ghost" | undefined>;
+    /** Present means controlled, for the life of the component. */
+    readonly pressed: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    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, and a second output for the same transition would be the same
+     * failure stated twice.
+     */
+    readonly pressedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly stateAttribute: typeof stateAttribute;
+    protected readonly appearance: {
+        size: _angular_core.Signal<"sm" | "md" | "lg">;
+        tone: _angular_core.Signal<"accent" | "secondary" | "success" | "warning" | "danger">;
+        variant: _angular_core.Signal<"solid" | "outline" | "ghost">;
+    };
+    protected readonly inert: {
+        refuses: _angular_core.Signal<boolean>;
+        nativelyDisabled: _angular_core.Signal<boolean>;
+        ariaDisabled: _angular_core.Signal<"true" | null>;
+    };
+    readonly waiting: _angular_core.Signal<boolean>;
+    private readonly start;
+    private readonly end;
+    readonly hasStart: _angular_core.Signal<boolean>;
+    protected readonly hasVisualSlot: _angular_core.Signal<boolean>;
+    private readonly state;
+    readonly isPressed: _angular_core.Signal<boolean>;
+    private readonly element;
+    private readonly destroyRef;
+    /**
+     * The capture phase, because a control that is unavailable or still working
+     * must refuse the activation before any listener the consumer attached to it
+     * can run.
+     */
+    constructor();
+    /**
+     * 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;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlToggleButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlToggleButton, "button[slToggleButton]", ["slToggleButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "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"; }, ["start", "end"], ["[slButtonStart]", "*", "[slButtonEnd]"], true, never>;
+}
+
+export { BUTTON_DEFAULTS_TOKEN, BUTTON_WAIT, SlButton, SlButtonEnd, SlButtonLink, SlButtonStart, SlIconButton, SlToggleButton, blockActivation, injectButtonDefaults, provideButtonDefaults, resolveInertness, resolveLoadingIndicator, stateAttribute };
+export type { ButtonDefaults, ButtonShape, ButtonSize, ButtonTone, ButtonType, ButtonVariant, ButtonWait };
+//# sourceMappingURL=slotted-angular-button.d.ts.map

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

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