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

package/types/slotted-angular-notification-center.d.ts.map

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

package/types/slotted-angular-number-field.d.ts

@@ -0,0 +1,402 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, NumberFieldMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the control sits at, matching the field around it. */
+type NumberFieldSize = 'sm' | 'md' | 'lg';
+/**
+ * How much frame the control shows. The three `text-field` ships, unchanged:
+ * `outline` takes the ground it is placed on, `subtle` sinks into the page, and
+ * `plain` shows nothing at rest, which is what a dense table needs.
+ */
+type NumberFieldVariant = 'outline' | 'subtle' | 'plain';
+/**
+ * Where the two steppers sit.
+ *
+ * `stacked` is one column at the inline end, which is what a form expects.
+ * `split` puts decrement at the inline start and increment at the inline end —
+ * the quantity picker's arrangement, and the only one whose targets clear the
+ * WCAG 2.2 minimum in both axes at every step. `none` withdraws them.
+ */
+type NumberFieldStepper = 'stacked' | 'split' | 'none';
+/**
+ * What happens to a value outside `min`…`max`. `blur` returns it to the range
+ * at the commit, `strict` refuses the keystroke that would leave it, and `none`
+ * keeps the value where the reader put it and reports `aria-invalid`.
+ */
+type NumberFieldClamp = 'blur' | 'strict' | 'none';
+/**
+ * When the text takes the locale's shape.
+ *
+ * `change` regroups on every keystroke, so `1234567` reads as `1.234.567` while
+ * it is being typed. Grouping exists to make a long number scannable, and the
+ * moment a reader most needs to check a magnitude is the moment they are
+ * getting it wrong. `commit` holds the reader's own text until blur, `Enter`, a
+ * stepper press or a key step.
+ *
+ * Neither decides when the *number* moves. It moves on every keystroke that
+ * parses, under both.
+ */
+type NumberFieldFormatOn = 'change' | 'commit';
+interface NumberFieldDefaults {
+    clamp: NumberFieldClamp;
+    formatOn: NumberFieldFormatOn;
+    size: NumberFieldSize;
+    stepper: NumberFieldStepper;
+    variant: NumberFieldVariant;
+}
+declare const NUMBER_FIELD_DEFAULTS: InjectionToken<NumberFieldDefaults>;
+/**
+ * An application decides once what its number fields look like, rather than
+ * repeating the same inputs on every amount in a form. A control that states
+ * any of them itself still wins.
+ *
+ * The locale and the two buttons' words come from the language in force
+ * (`provideSlotted`): one locale for the whole application decides the decimal
+ * separator, the grouping and the numbering system, and a form where one field
+ * reads `1.234` as a thousand and another as one point two three four is a
+ * form that loses money.
+ */
+declare function provideNumberFieldDefaults(defaults: Partial<NumberFieldDefaults>): {
+    provide: InjectionToken<NumberFieldDefaults>;
+    useFactory: () => NumberFieldDefaults;
+};
+/** What a number field renders as here, before it states anything of its own. */
+declare function injectNumberFieldDefaults(): NumberFieldDefaults;
+/**
+ * What the frame needs to know about the control inside it, and what the
+ * control needs the frame to call.
+ *
+ * It is an abstract class rather than an import so the two directives can
+ * depend on each other without a cycle — the shape `field` and `text-field`
+ * already have. The input provides itself as this, and the frame queries it.
+ */
+declare abstract class SlNumberFieldControl {
+    /** The identifier the steppers point `aria-controls` at. */
+    abstract readonly controlId: Signal<string | null>;
+    /** Whether a step up would leave the range, which is what disables a button. */
+    abstract readonly atMax: Signal<boolean>;
+    /** Whether a step down would. */
+    abstract readonly atMin: Signal<boolean>;
+    /** The submission name the frame's hidden input carries, if there is one. */
+    abstract readonly submissionName: Signal<string | null>;
+    /** The form that hidden input belongs to, when it is not the ancestor one. */
+    abstract readonly submissionForm: Signal<string | null>;
+    /** The raw number the family holds, for the hidden input the frame renders. */
+    abstract readonly numberValue: Signal<number | null>;
+    abstract readonly resolvedDisabled: Signal<boolean | undefined>;
+    abstract readonly resolvedReadOnly: Signal<boolean | undefined>;
+    abstract readonly resolvedInvalid: Signal<boolean | undefined>;
+    /** Moves the value by one step and returns focus to it. */
+    abstract stepBy(direction: 1 | -1, source: Event | undefined): void;
+    /**
+     * Moves the value by whole steps a `scrub` drag travelled, signed, by the
+     * large step under `Shift` and the small one under `Alt`.
+     */
+    abstract scrubBy(steps: number, source: PointerEvent): void;
+    /** The native element, which a scrub focuses and reads the direction from. */
+    abstract readonly inputElement: HTMLInputElement;
+}
+
+/**
+ * The frame: one number, and the two buttons that move it.
+ *
+ * **It is not the control.** The element carrying `data-ui` is the consumer's
+ * own box with no role; the `input` inside it holds the value, the identifier
+ * and the APG's `spinbutton` role. WAI-ARIA settles the shape: a `spinbutton`
+ * may hold only non-interactive presentational children, so the two steppers
+ * are the control's siblings rather than its children.
+ *
+ * **The split arrangement is written in the order it is painted.** Decrement
+ * before the value and increment after it, rather than one box reordered with
+ * `order`, so the reading order and the painted order are the same one.
+ *
+ * **Angular pays one element for that frame, and React pays none.** React can
+ * render a wrapper from inside a component; an Angular directive cannot create
+ * a box around its own host. `slNumberFieldInput` injects this class, so a
+ * control written without the frame is a compile-time failure rather than a
+ * silent one.
+ */
+declare class SlNumberField {
+    /** Defaults to the field, then to the token, then to `md`. */
+    readonly size: _angular_core.InputSignal<NumberFieldSize | undefined>;
+    /** Defaults to the token, then to `outline`. */
+    readonly variant: _angular_core.InputSignal<NumberFieldVariant | undefined>;
+    /** Where the two steppers sit. Defaults to the token, then to `stacked`. */
+    readonly stepper: _angular_core.InputSignal<NumberFieldStepper | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * `increment` and `decrement` buttons' accessible names.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<NumberFieldMessages> | undefined>;
+    private readonly defaults;
+    private readonly field;
+    /**
+     * The control inside. It provides itself as `SlNumberFieldControl`, so the
+     * frame can read the bounds, the submission name and the shared states
+     * without either directive importing the other.
+     */
+    readonly control: _angular_core.Signal<SlNumberFieldControl | undefined>;
+    readonly resolvedSize: _angular_core.Signal<NumberFieldSize>;
+    readonly resolvedVariant: _angular_core.Signal<NumberFieldVariant>;
+    readonly resolvedStepper: _angular_core.Signal<NumberFieldStepper>;
+    /** The family's words in the language in force, with this field's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<NumberFieldMessages>;
+    /** Whether a `slNumberFieldScrub` inside is being dragged. */
+    readonly scrubbing: _angular_core.WritableSignal<boolean>;
+    /** A control nobody can change has two buttons that would lie about it. */
+    readonly inert: _angular_core.Signal<boolean>;
+    protected readonly incrementDisabled: _angular_core.Signal<boolean>;
+    protected readonly decrementDisabled: _angular_core.Signal<boolean>;
+    protected readonly hiddenValue: _angular_core.Signal<string>;
+    private delay;
+    private interval;
+    constructor();
+    /**
+     * One step now, then repeating while the button is held. A coarse pointer
+     * waits longer before the first repeat, because a finger that is starting to
+     * scroll rests on the button first.
+     */
+    protected press(direction: 1 | -1, event: PointerEvent): void;
+    protected release(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlNumberField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlNumberField, "[slNumberField]", ["slNumberField"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "stepper": { "alias": "stepper"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, ["control"], ["[slNumberFieldStart]", "*", "[slNumberFieldEnd]"], true, never>;
+}
+
+/**
+ * The control itself: the number, the identifier, and everything the field
+ * around it says.
+ *
+ * **The element is `type="text"` and carries the APG's `spinbutton` role.**
+ * `type="number"` empties itself whenever the text is not a valid
+ * floating-point number, so no grouping separator, no decimal comma and no
+ * currency affix survives it.
+ *
+ * **The text belongs to the element and the number belongs to the family.** The
+ * number moves on every keystroke that parses. Under `formatOn="change"`, the
+ * default, the text takes the locale's shape on that same keystroke: the
+ * grouping a long number is read by appears while it is being typed, and the
+ * caret comes back to the character it was on because it is counted in the
+ * reader's own characters rather than in string indices. Under
+ * `formatOn="commit"` the text is the reader's until blur, `Enter`, a stepper
+ * press, a key step or a wheel turn.
+ *
+ * Rounding, padding and clamping belong to the commit under both. A keystroke
+ * never takes away a nought the reader has just typed.
+ *
+ * **Unset means ask the field.** `disabled`, `readOnly` and `invalid` default to
+ * `undefined` rather than `false`. A value the consumer wrote as a static
+ * attribute is read before the host binding computes, so the binding never
+ * writes over it.
+ */
+declare class SlNumberFieldInput implements ControlValueAccessor, OnInit, SlNumberFieldControl {
+    /**
+     * Present means the consumer owns the number, for the life of the component.
+     * `null` is empty, and `undefined` is the absence that makes the control
+     * uncontrolled — the two are different answers.
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number | null | undefined, unknown>;
+    /** The number the control starts from when nobody else writes one. */
+    readonly defaultValue: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The amount `Shift` and the page keys move by. Defaults to `step * 10`. */
+    readonly largeStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The amount `Alt` moves by. Defaults to `step / 10`. */
+    readonly smallStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Where an empty control starts stepping from. Defaults to `min`, then nought. */
+    readonly stepFrom: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly snapToStep: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Where a value outside the range goes, and when. Defaults to the token, then `blur`. */
+    readonly clamp: _angular_core.InputSignal<NumberFieldClamp | undefined>;
+    /** How the value is written and read back, through `Intl.NumberFormat`. */
+    readonly format: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    /** When the text takes that shape. Defaults to the token, then `change`. */
+    readonly formatOn: _angular_core.InputSignal<NumberFieldFormatOn | undefined>;
+    /** BCP 47. Defaults to the language in force (`provideSlotted`). */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Lets the wheel move the value while the control has focus. Off by default:
+     * a reader scrolling a form must not change an amount by passing over it.
+     */
+    readonly wheel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Unstated rather than `false`, so the control defers to the field. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    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 value, the value it replaces,
+     * the reason, the originating event and `cancel()`. There is no `[(value)]`,
+     * because a two-way binding has one slot and can carry none of those; a form
+     * gets the same movement through `ControlValueAccessor`.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<number | null>>;
+    private readonly element;
+    /**
+     * The frame around the control. Injected without `optional`, so an `input`
+     * written without it fails at construction rather than silently losing its
+     * border, its ring and the place its two buttons stand.
+     */
+    readonly numberField: SlNumberField;
+    private readonly field;
+    private readonly defaults;
+    private readonly appLocale;
+    private readonly writtenId;
+    private readonly writtenName;
+    private readonly writtenForm;
+    private readonly writtenInputMode;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    private readonly writtenReadonly;
+    /** What the family holds when nobody else owns it. */
+    private readonly own;
+    /** What the element is showing. Never a second copy of the number. */
+    private readonly text;
+    private readonly formDisabled;
+    private onChangeFn;
+    private onTouchedFn;
+    /**
+     * One formatter, rebuilt only when the locale or the format changes. The
+     * options object is read through a signal, so an inline object handed on
+     * every change detection does not rebuild the parser.
+     */
+    private readonly formatter;
+    /** Present means the consumer owns it; absent means the directive does. */
+    private readonly controlled;
+    readonly numberValue: _angular_core.Signal<number | null>;
+    readonly valueText: _angular_core.Signal<string | null>;
+    readonly resolvedClamp: _angular_core.Signal<NumberFieldClamp>;
+    protected readonly resolvedFormatOn: _angular_core.Signal<NumberFieldFormatOn>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    /**
+     * Unstated, the control asks the field. Under `clamp="none"` nothing returns
+     * a number outside `min`…`max` to the range, so the control reports it.
+     */
+    private readonly outsideRange;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    readonly controlId: _angular_core.Signal<string | null>;
+    readonly submissionName: _angular_core.Signal<string | null>;
+    readonly submissionForm: _angular_core.Signal<string | null>;
+    private readonly parsedText;
+    readonly atMax: _angular_core.Signal<boolean>;
+    readonly atMin: _angular_core.Signal<boolean>;
+    /**
+     * The software keyboard, derived from the props rather than from the user
+     * agent. Neither numeric keypad offers a minus sign on every platform, so a
+     * control that admits a negative asks for the full keyboard.
+     */
+    protected readonly resolvedInputMode: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<string | null>;
+    protected readonly ariaRequired: _angular_core.Signal<string | null>;
+    protected readonly disabledAttribute: _angular_core.Signal<"" | null>;
+    protected readonly readonlyAttribute: _angular_core.Signal<"" | null>;
+    constructor();
+    /**
+     * Angular creates every directive in a template before it binds any input, so
+     * the starting value is read here rather than in the constructor: read there,
+     * `defaultValue` is always its own default and the control starts empty.
+     */
+    ngOnInit(): void;
+    /** The native element, for `focus()`, `select()` and `setSelectionRange()`. */
+    get inputElement(): HTMLInputElement;
+    /** Steps up by one step and reports `programmatic`. */
+    increment(): void;
+    /** Steps down by one step and reports `programmatic`. */
+    decrement(): void;
+    /** What a `slNumberFieldScrub` drag calls, once per whole step travelled. */
+    scrubBy(steps: number, source: PointerEvent): void;
+    /** What the frame's two buttons call. Focus returns to the value. */
+    stepBy(direction: 1 | -1, source: Event | undefined): void;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    /**
+     * The keystroke filter. `beforeinput` is where a keystroke, a paste and a
+     * drop all arrive before the element changes, and it is the only place a
+     * character that cannot be part of a number can be refused without moving
+     * the caret.
+     */
+    protected onBeforeInput(event: InputEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    /**
+     * The wheel, when it is asked for, and never otherwise. It is a native
+     * listener rather than a host binding because the event has to be cancelled,
+     * and a host listener on `wheel` is passive in some browsers.
+     */
+    private attachWheel;
+    /** Formats what the reader typed and puts the value back in range. */
+    private commit;
+    private move;
+    /**
+     * Asks to move, and says whether anything did. A refused request answers
+     * `false`, and the caller uses that to decide what the element shows: a
+     * control that wrote the new number into the text regardless would show a
+     * value the consumer never accepted.
+     */
+    private request;
+    private settle;
+    /** One place the element's text is written, so the signal never drifts from it. */
+    private write;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlNumberFieldInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlNumberFieldInput, "input[slNumberFieldInput]", ["slNumberFieldInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "smallStep": { "alias": "smallStep"; "required": false; "isSignal": true; }; "stepFrom": { "alias": "stepFrom"; "required": false; "isSignal": true; }; "snapToStep": { "alias": "snapToStep"; "required": false; "isSignal": true; }; "clamp": { "alias": "clamp"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "formatOn": { "alias": "formatOn"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "wheel": { "alias": "wheel"; "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; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * An adornment before the value in the reading direction: a currency mark, a
+ * unit, an icon. Named for the direction rather than for a side, so the same
+ * markup puts the mark before the amount in both directions.
+ *
+ * It is a sibling of the number rather than part of it. A symbol that belongs
+ * *inside* the value — the `R$` of a currency format, a percent sign — is
+ * `format`'s job and arrives through `Intl` as part of the string the control
+ * holds; this one is never selected, never copied and never parsed.
+ */
+declare class SlNumberFieldStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlNumberFieldStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlNumberFieldStart, "[slNumberFieldStart]", ["slNumberFieldStart"], {}, {}, never, never, true, never>;
+}
+/** An adornment after the value in the reading direction. */
+declare class SlNumberFieldEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlNumberFieldEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlNumberFieldEnd, "[slNumberFieldEnd]", ["slNumberFieldEnd"], {}, {}, never, never, true, never>;
+}
+/**
+ * A mark that moves the number when it is dragged sideways — the design
+ * tools' gesture. Placed inside `slNumberFieldStart` or `slNumberFieldEnd`,
+ * where the frame it belongs to is its ancestor:
+ *
+ * ```html
+ * <span slNumberFieldStart><span slNumberFieldScrub>W</span></span>
+ * ```
+ *
+ * Each `sensitivity` pixels towards the inline end is one step up; `Shift`
+ * moves by the large step and `Alt` by the small one, as on the keyboard. It
+ * is hidden from assistive technology and takes no focus: the input's arrow
+ * keys are the same movement.
+ */
+declare class SlNumberFieldScrub {
+    /** Pixels of horizontal travel per step. Defaults to 2. */
+    readonly sensitivity: _angular_core.InputSignal<number>;
+    private readonly frame;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    private travel;
+    protected begin(event: PointerEvent): void;
+    protected drag(event: PointerEvent): void;
+    protected end(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlNumberFieldScrub, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlNumberFieldScrub, "[slNumberFieldScrub]", ["slNumberFieldScrub"], { "sensitivity": { "alias": "sensitivity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NUMBER_FIELD_DEFAULTS, SlNumberField, SlNumberFieldControl, SlNumberFieldEnd, SlNumberFieldInput, SlNumberFieldScrub, SlNumberFieldStart, injectNumberFieldDefaults, provideNumberFieldDefaults };
+export type { NumberFieldClamp, NumberFieldDefaults, NumberFieldFormatOn, NumberFieldSize, NumberFieldStepper, NumberFieldVariant };
+//# sourceMappingURL=slotted-angular-number-field.d.ts.map

package/types/slotted-angular-number-field.d.ts.map

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