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

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

@@ -0,0 +1,362 @@
+import * as _slotted_core_date from '@slotted/core/date';
+import { TimeGranularity, PlainDateTime, SegmentState, DateTimeHalf, PlainTime, PlainDate, SegmentFieldName, DateTimePatternPart } from '@slotted/core/date';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, DatetimeFieldMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+
+/** The type step the control sits at, matching the field around it. */
+type DateTimeFieldSize = 'sm' | 'md' | 'lg';
+/**
+ * How much frame the control shows. The three steps `text-field` set, so a form
+ * holding a name and a datetime shows one frame twice rather than two frames.
+ */
+type DateTimeFieldVariant = 'outline' | 'subtle' | 'plain';
+/**
+ * The question a consumer asks about the clock. Which variant of each — `h11`
+ * or `h12`, `h23` or `h24` — is the locale's own, and `Intl` answers it.
+ */
+type DateTimeFieldHourCycle = 12 | 24;
+interface DateTimeFieldDefaults {
+    /** Only `gregory` today. The axis exists so a second calendar can arrive. */
+    calendar: 'gregory';
+    /** `0` is Sunday. Unset asks the locale. */
+    firstDayOfWeek: number | undefined;
+    /** How much of the time half is written. The date half is always whole. */
+    granularity: TimeGranularity;
+    /** Unset means the locale decides both the cycle and its variant. */
+    hourCycle: DateTimeFieldHourCycle | undefined;
+    /** Whether `+`, `-` and `=` open the duration expression. */
+    relative: boolean;
+    size: DateTimeFieldSize;
+    /** Which zone answers "what is the time now". Unset means the runtime's own. */
+    timeZone: string | undefined;
+    variant: DateTimeFieldVariant;
+    /** Two typed digits below this many years ahead are read as this century. */
+    yearPivot: number | undefined;
+}
+declare const DATE_TIME_FIELD_DEFAULTS: InjectionToken<DateTimeFieldDefaults>;
+/**
+ * An application decides once what its datetimes look like, which clock they
+ * run on and which zone answers "now", rather than repeating the same inputs on
+ * every control in a form. A control that states any of them itself still
+ * wins. The locale that writes them, and the words the controls announce, come
+ * from the language in force (`provideSlotted`).
+ */
+declare function provideDateTimeFieldDefaults(defaults: Partial<DateTimeFieldDefaults>): {
+    provide: InjectionToken<DateTimeFieldDefaults>;
+    useFactory: () => DateTimeFieldDefaults;
+};
+/** What a datetime field renders as here, before it states anything itself. */
+declare function injectDateTimeFieldDefaults(): DateTimeFieldDefaults;
+
+/**
+ * What a request carries beyond the value: the segments, so a half-written
+ * value can be saved, and which half is still missing.
+ *
+ * There is no `crossesMidnight` here. `time-field` raises that flag because a
+ * `PlainTime` has no day to put a crossing in, and names this family as the
+ * consumer that would answer it — here the day exists, so the crossing is
+ * already in the value.
+ */
+interface DateTimeFieldChangeRequest extends ChangeRequest<PlainDateTime | null> {
+    readonly segments: SegmentState;
+    readonly incomplete: DateTimeHalf | null;
+}
+/**
+ * A segmented datetime control: one spin button per field, in the order the
+ * locale writes them, with all seven fields in one row.
+ *
+ * **It is not a `slDateField` beside a `slTimeField`.** Two nested family roots
+ * would be two groups, two values and two `SegmentState`s. The order of the
+ * halves and the literal between them come from one combined
+ * `Intl.DateTimeFormat` that neither of them can see, and a digit that fills
+ * the last date segment advances across the boundary into the first time
+ * segment — which two roots cannot do.
+ *
+ * **Angular is a component with a template and a `ControlValueAccessor`**,
+ * because a datetime belongs in a Reactive Form and Angular has the integration
+ * point for it. It also implements `Validator`, and it reports five rules where
+ * Kendo — the only surveyed implementation that validates at all — reports
+ * three: `dateTimeParse`, `dateTimeIncomplete`, `dateTimeMin`, `dateTimeMax`
+ * and `dateTimeUnavailable`.
+ *
+ * **The missing half is said out loud**, on the root, on the request and in the
+ * validator. Every surveyed implementation reports an empty control and loses
+ * what was written.
+ */
+declare class SlDateTimeField implements ControlValueAccessor, Validator, OnInit {
+    /** Present means the consumer owns the value. */
+    readonly value: _angular_core.InputSignal<PlainDateTime | null | undefined>;
+    /** The value the control starts from when nobody else writes one. */
+    readonly defaultValue: _angular_core.InputSignal<PlainDateTime | null | undefined>;
+    /** The earliest whole value: where the range starts. Also a form rule. */
+    readonly min: _angular_core.InputSignal<PlainDateTime | undefined>;
+    /** The latest whole value: where the range ends. Also a form rule. */
+    readonly max: _angular_core.InputSignal<PlainDateTime | undefined>;
+    /**
+     * The earliest time of **every** day inside the range.
+     *
+     * It applies beside `min` rather than instead of it, which MUI's own
+     * validation page records that it cannot do.
+     */
+    readonly minTime: _angular_core.InputSignal<PlainTime | undefined>;
+    /** The latest time of every day inside the range, beside `max`. */
+    readonly maxTime: _angular_core.InputSignal<PlainTime | undefined>;
+    /** Refuses particular days — a holiday, a closed shop, a booked room. */
+    readonly isDateUnavailable: _angular_core.InputSignal<((date: PlainDate) => boolean) | undefined>;
+    /**
+     * Refuses particular times on a particular day. Two predicates rather than
+     * one, because a day-level answer cannot be derived from a datetime-level
+     * predicate without probing every step of that day.
+     */
+    readonly isTimeUnavailable: _angular_core.InputSignal<((time: PlainTime, date: PlainDate) => boolean) | undefined>;
+    /**
+     * BCP 47. Decides the field order, the separators and the placeholder.
+     * Unset, the language in force decides.
+     */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Which zone answers "what is the time now", and nothing else. */
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly hourCycle: _angular_core.InputSignal<DateTimeFieldHourCycle | undefined>;
+    readonly granularity: _angular_core.InputSignal<TimeGranularity | undefined>;
+    readonly calendar: _angular_core.InputSignal<"gregory" | undefined>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | undefined>;
+    readonly yearPivot: _angular_core.InputSignal<number | undefined>;
+    /**
+     * What an empty segment steps from, and what a duration resolves against.
+     * Unset, both are the current datetime in `timeZone`.
+     */
+    readonly referenceDateTime: _angular_core.InputSignal<PlainDateTime | undefined>;
+    readonly size: _angular_core.InputSignal<DateTimeFieldSize | undefined>;
+    readonly variant: _angular_core.InputSignal<DateTimeFieldVariant | undefined>;
+    /** 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>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Draws a button that empties both halves and returns focus to the control. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether `+`, `-` and `=` open the duration expression. */
+    readonly relative: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * clear button's name and the duration expression's name.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<DatetimeFieldMessages> | undefined>;
+    /** The name a plain form post carries the ISO string under. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * One output for one transition, carrying the value, the value it replaces,
+     * the segments, the half that is still missing, 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.
+     */
+    /**
+     * The accessible name, when it is bound rather than written: a static
+     * `aria-label` is read once from the host, and a family naming this field
+     * from its own input — `datetime-range-picker` names its two ends — has no
+     * static attribute to write.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<DateTimeFieldChangeRequest>;
+    private readonly element;
+    private readonly defaults;
+    private readonly appLocale;
+    /** The family's words in the language in force, with this field's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<DatetimeFieldMessages>;
+    private readonly field;
+    /** Read before the host binding computes, so it never writes over it. */
+    protected readonly writtenLabel: string | null;
+    private readonly writtenId;
+    private readonly writtenLabelledBy;
+    private readonly writtenDescribedBy;
+    protected readonly valueTextId: string;
+    private readonly segments;
+    private readonly formDisabled;
+    /**
+     * What datetime it is, resolved after construction rather than during it, so
+     * a server and a browser never disagree about the markup. Nothing is drawn
+     * from it: it is the value an empty segment steps to and a duration resolves
+     * from.
+     */
+    private readonly clock;
+    protected readonly activeField: _angular_core.WritableSignal<SegmentFieldName | undefined>;
+    /** The duration being written, or `null` while the segments are showing. */
+    protected readonly expression: _angular_core.WritableSignal<string | null>;
+    private onChangeFn;
+    private onTouchedFn;
+    private onValidatorChangeFn;
+    protected readonly resolvedGranularity: _angular_core.Signal<TimeGranularity>;
+    protected readonly resolvedCalendar: _angular_core.Signal<"gregory">;
+    protected readonly format: _angular_core.Signal<_slotted_core_date.DateTimeFormat>;
+    protected readonly dataCycle: _angular_core.Signal<"12" | "24">;
+    protected readonly fields: _angular_core.Signal<SegmentFieldName[]>;
+    /**
+     * One box per half, and the only place the row is allowed to break.
+     *
+     * Flexbox breaks a line between any two items and offers no way to forbid one
+     * place, so the boundary has to be a box rather than a rule.
+     */
+    protected readonly halves: _angular_core.Signal<{
+        half: DateTimeHalf;
+        parts: DateTimePatternPart[];
+    }[]>;
+    /** What an empty segment steps from, in the shape the engine reads. */
+    private readonly reference;
+    private readonly anchor;
+    /** The value the segments make, or `null` while either half is unfinished. */
+    readonly dateTime: _angular_core.Signal<PlainDateTime | null>;
+    /** Which half is still missing, and `null` when none is. */
+    readonly incomplete: _angular_core.Signal<DateTimeHalf | null>;
+    protected readonly iso: _angular_core.Signal<string>;
+    protected readonly spokenValue: _angular_core.Signal<string>;
+    protected readonly resolved: _angular_core.Signal<PlainDateTime | null>;
+    /** Whether the expression landed on a different day from the anchor's. */
+    protected readonly rollsDay: _angular_core.Signal<boolean>;
+    protected readonly previewTime: _angular_core.Signal<string>;
+    protected readonly previewDate: _angular_core.Signal<string>;
+    readonly resolvedSize: _angular_core.Signal<DateTimeFieldSize>;
+    readonly resolvedVariant: _angular_core.Signal<DateTimeFieldVariant>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedRequired: _angular_core.Signal<boolean | undefined>;
+    /**
+     * Validity the family owns, beside the validity the consumer states.
+     *
+     * Both pairs of bounds apply at once — the whole-value one and the window
+     * that repeats on every day — which is the combination MUI's own validation
+     * page records that it cannot ship.
+     */
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    protected readonly controlId: _angular_core.Signal<string | null>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
+    protected readonly ariaRequired: _angular_core.Signal<"true" | null>;
+    protected readonly ariaReadonly: _angular_core.Signal<"true" | null>;
+    protected readonly ariaDisabled: _angular_core.Signal<"true" | null>;
+    private readonly editable;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    writeValue(value: PlainDateTime | null | undefined): void;
+    registerOnChange(fn: (value: PlainDateTime | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnValidatorChange(fn: () => void): void;
+    /**
+     * The rules no other validator can see, and one no surveyed implementation
+     * reports at all.
+     *
+     * `dateTimeIncomplete` is that one: a reader who wrote a day and left is not
+     * an empty control, and a form that says "required" there is answering a
+     * different question. `required` itself is left to Angular's own, because a
+     * form already has a word for it and two would disagree.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /** Puts focus on the first segment, which is where typing starts. */
+    focus(): void;
+    /**
+     * Where a press on the frame puts the reader: the first field still waiting
+     * for a value, and the first field of the value when none is.
+     */
+    focusEntry(): void;
+    protected onRootMouseDown(event: MouseEvent): void;
+    /**
+     * Safari does not focus a `div` on a press even when it carries a
+     * `tabindex`, so the press says so itself rather than relying on it.
+     */
+    protected onSegmentMouseDown(event: MouseEvent): void;
+    /** Empties both halves at once, with the `clear` reason. */
+    clear(source?: Event): void;
+    /**
+     * A key the field acted on is the field's, and nothing above it sees it. A
+     * `div` with `role="spinbutton"` is invisible to every "is the target
+     * editable" guard an application writes, and `preventDefault` alone does not
+     * help: a shortcut handler reads the key, not the default.
+     */
+    private consume;
+    /**
+     * The keys are handled on the host rather than on each segment, so a
+     * consumer's own `(keydown)` on the same element still runs before the family
+     * stops the event — which is the composition React gets by calling the
+     * consumer's handler first.
+     */
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onExpressionInput(event: Event): void;
+    protected onExpressionKeyDown(event: KeyboardEvent): void;
+    /** Commits the expression when it resolves, and abandons it when it does not. */
+    protected commitExpression(source?: Event): void;
+    /**
+     * A whole value, pasted. The locale's shape is read first and ISO 8601 after
+     * it; text that is neither but reads as a duration opens the expression, so
+     * pasting `+2d` does what typing it does.
+     */
+    protected onPaste(event: ClipboardEvent): void;
+    /** A run of typed digits ends when focus leaves. */
+    protected onBlur(): void;
+    protected halfOf(field: SegmentFieldName): DateTimeHalf;
+    protected valueOf(field: SegmentFieldName): number | null;
+    /**
+     * The day's own maximum is the month's, which is why the range is asked with
+     * the year and the month rather than assumed to be 31.
+     */
+    protected rangeOf(field: SegmentFieldName): {
+        min: number;
+        max: number;
+    };
+    /**
+     * What a reader hears instead of the number. The day period is why it is not
+     * optional: `aria-valuenow` there is `0` or `1`, which is not a name in any
+     * language — and a month reads better as its own name than as a number.
+     */
+    protected spokenOf(field: SegmentFieldName): string | null;
+    /**
+     * What one field shows. A finished value is padded to the field's width so
+     * the columns hold their place; a value still being typed is not, because a
+     * padded run shows numbers nobody typed.
+     */
+    protected textOf(field: SegmentFieldName): string;
+    /** Exactly one segment is in the tab sequence, which is the roving model. */
+    protected tabIndexOf(field: SegmentFieldName): number;
+    /** Whether both pairs of bounds, or either predicate, refuse a whole value. */
+    private refuses;
+    private focusField;
+    private moveBy;
+    /**
+     * Moves the segments, and asks before the derived value moves with them.
+     *
+     * A run of typed digits moves the display and not the value: typing `23` into
+     * an hour passes through `2` on the way, and `2` is a time the arithmetic
+     * accepts and nobody meant. The request is emitted when the run ends.
+     */
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDateTimeField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDateTimeField, "[slDateTimeField]", ["slDateTimeField"], { "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; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "isTimeUnavailable": { "alias": "isTimeUnavailable"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "yearPivot": { "alias": "yearPivot"; "required": false; "isSignal": true; }; "referenceDateTime": { "alias": "referenceDateTime"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "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; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "relative": { "alias": "relative"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["[slDateTimeFieldStart]", "[slDateTimeFieldEnd]"], true, never>;
+}
+
+/**
+ * An adornment before the value in the reading direction: a calendar mark, a
+ * label, a zone name. Named for the direction rather than for a side, so the
+ * same markup puts the mark before the value in both directions.
+ *
+ * It is a directive on the consumer's own element, so an `icon`, a `kbd` or a
+ * `span` all work and none of them loses its own semantics. The stylesheet
+ * sizes any icon inside it from the control's own glyph scale.
+ */
+declare class SlDateTimeFieldStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDateTimeFieldStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDateTimeFieldStart, "[slDateTimeFieldStart]", ["slDateTimeFieldStart"], {}, {}, never, never, true, never>;
+}
+/** An adornment after the value in the reading direction. */
+declare class SlDateTimeFieldEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDateTimeFieldEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDateTimeFieldEnd, "[slDateTimeFieldEnd]", ["slDateTimeFieldEnd"], {}, {}, never, never, true, never>;
+}
+
+export { DATE_TIME_FIELD_DEFAULTS, SlDateTimeField, SlDateTimeFieldEnd, SlDateTimeFieldStart, injectDateTimeFieldDefaults, provideDateTimeFieldDefaults };
+export type { DateTimeFieldChangeRequest, DateTimeFieldDefaults, DateTimeFieldHourCycle, DateTimeFieldSize, DateTimeFieldVariant };
+//# sourceMappingURL=slotted-angular-datetime-field.d.ts.map

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

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