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

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

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

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

@@ -0,0 +1,150 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** The type step the control sits at, matching the field around it. */
+type TextareaSize = 'sm' | 'md' | 'lg';
+/** How much frame the control shows. The three `text-field` draws. */
+type TextareaVariant = 'outline' | 'subtle' | 'plain';
+/**
+ * Which way the manual handle may drag. `block` is the default rather than the
+ * platform's `both`: a control wider than its field breaks the field's grid,
+ * and a reader who widens one control in a form has broken its alignment.
+ */
+type TextareaResize = 'block' | 'none' | 'both';
+interface TextareaDefaults {
+    mono: boolean;
+    resize: TextareaResize;
+    size: TextareaSize;
+    variant: TextareaVariant;
+}
+declare const TEXTAREA_DEFAULTS: InjectionToken<TextareaDefaults>;
+/**
+ * An application decides once what its multi-line controls look like and
+ * whether their handle drags, rather than repeating the same inputs on every
+ * control. A control that states any of them itself still wins, and a control
+ * inside a field takes the field's step over this token's.
+ */
+declare function provideTextareaDefaults(defaults: Partial<TextareaDefaults>): {
+    provide: InjectionToken<TextareaDefaults>;
+    useFactory: () => TextareaDefaults;
+};
+/** What a textarea renders as here, before it states anything of its own. */
+declare function injectTextareaDefaults(): TextareaDefaults;
+
+/**
+ * Many lines of text, in the element that already holds them.
+ *
+ * **No frame.** `text-field` wraps its input because an adornment and two
+ * buttons have to sit inside one border and a void element can hold no child.
+ * Nothing surveyed puts an adornment inside a textarea — the corner is where
+ * the resize handle goes — so this family is the control itself, and the two
+ * anatomies differ on purpose rather than matching for symmetry.
+ *
+ * **The platform grows it.** `autoSize` is CSS `field-sizing: content`. Nothing
+ * is measured on the main thread, no line height is cached and no layout is
+ * read per keystroke, which is what `cdkTextareaAutosize` does. `field-sizing`
+ * shrinkwraps, so `rows` stops being the floor: the two row counts reach the
+ * stylesheet as custom properties, and it states the floor and the ceiling in
+ * line boxes.
+ *
+ * **Enter makes a line.** Nothing is bound to a key. WAI-ARIA notes the
+ * difference between a single-line and a multi-line text control, and
+ * `docs/component-features.md` §6 requires it: a multi-line control never
+ * submits implicitly.
+ */
+declare class SlTextarea implements ControlValueAccessor, OnInit {
+    /** Defaults to the field, then to the token, then to `md`. */
+    readonly size: _angular_core.InputSignal<TextareaSize | undefined>;
+    /** Defaults to the token, then to `outline`. */
+    readonly variant: _angular_core.InputSignal<TextareaVariant | undefined>;
+    /** Defaults to the token, then to `block`. Withdrawn while `autoSize` is on. */
+    readonly resize: _angular_core.InputSignal<TextareaResize | undefined>;
+    /** Sets the value in the monospaced family, for a payload or a template. */
+    readonly mono: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Grows with the content, through the platform rather than a measurement. */
+    readonly autoSize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The floor, in rows. It is the element's own `rows` as well. */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The ceiling `autoSize` grows to, in rows. It cannot be removed: a control
+     * that grows forever pushes the page out from under the caret, which is the
+     * defect every auto-grow implementation ships first.
+     */
+    readonly maxRows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Present means the consumer owns the value. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** The value the control starts from when nobody else writes one. */
+    readonly defaultValue: _angular_core.InputSignal<string | 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>;
+    /** Publishes the length of the value to the field, which draws the count. */
+    readonly showCount: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The native limit, as a binding. Without this input `[maxLength]` would set
+     * the element's property and the count would never see it; a static
+     * `maxlength` attribute is read as written.
+     */
+    readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The limit the count is measured against. Defaults to `maxlength`. */
+    readonly countMax: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** One output for one transition, carrying the reason and `cancel()`. */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    private readonly element;
+    private readonly defaults;
+    private readonly field;
+    private readonly writtenId;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    private readonly writtenReadonly;
+    private readonly writtenMaxLength;
+    /** What the element is showing. Never a second copy of the value. */
+    private readonly mirror;
+    private readonly formDisabled;
+    private onChangeFn;
+    private onTouchedFn;
+    readonly resolvedSize: _angular_core.Signal<TextareaSize>;
+    readonly resolvedVariant: _angular_core.Signal<TextareaVariant>;
+    readonly resolvedMono: _angular_core.Signal<boolean>;
+    /**
+     * A control that sizes itself and a handle that fixes its size disagree on
+     * the next keystroke, so the handle is withdrawn rather than left to fight.
+     */
+    readonly resolvedResize: _angular_core.Signal<TextareaResize>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    protected readonly controlId: _angular_core.Signal<string | null>;
+    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>;
+    protected readonly maxLengthAttribute: _angular_core.Signal<string | number | null>;
+    private readonly limit;
+    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, where
+     * `defaultValue` is always still `undefined`.
+     */
+    ngOnInit(): void;
+    /** The native element, for `focus()`, `select()` and `setSelectionRange()`. */
+    get textareaElement(): HTMLTextAreaElement;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTextarea, "textarea[slTextarea]", ["slTextarea"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "mono": { "alias": "mono"; "required": false; "isSignal": true; }; "autoSize": { "alias": "autoSize"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "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; }; "showCount": { "alias": "showCount"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "countMax": { "alias": "countMax"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { SlTextarea, TEXTAREA_DEFAULTS, injectTextareaDefaults, provideTextareaDefaults };
+export type { TextareaDefaults, TextareaResize, TextareaSize, TextareaVariant };
+//# sourceMappingURL=slotted-angular-textarea.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-textarea.d.ts","sources":["../../textarea/src/textarea-defaults.ts","../../textarea/src/textarea.ts"],"mappings":";;;;;AAEA;AACM,KAAM,YAAY;AAExB;AACM,KAAM,eAAe;AAE3B;;;;AAIG;AACG,KAAM,cAAc;UAET,gBAAgB;;YAEvB,cAAc;UAChB,YAAY;aACT,eAAe;AACzB;AASD,cAAa,iBAAiB,EAAA,cAAA,CAAA,gBAAA;AAK9B;;;;;AAKG;AACH,iBAAgB,uBAAuB,WAAW,OAAO,CAAC,gBAAgB;;sBAGtD,gBAAgB;AAEnC;AAED;AACA,iBAAgB,sBAAsB,IAAI,gBAAgB;;ACpB1D;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAoCa,UAAW,YAAW,oBAAoB,EAAE,MAAM;;mBAEhD,aAAA,CAAA,WAAA,CAAA,YAAA;;sBAEG,aAAA,CAAA,WAAA,CAAA,eAAA;;qBAED,aAAA,CAAA,WAAA,CAAA,cAAA;;mBAEF,aAAA,CAAA,wBAAA;;uBAII,aAAA,CAAA,wBAAA;;mBAEJ,aAAA,CAAA,wBAAA;AACb;;;;AAIG;sBACa,aAAA,CAAA,wBAAA;;oBAGF,aAAA,CAAA,WAAA;;2BAEO,aAAA,CAAA,WAAA;;uBAEJ,aAAA,CAAA,wBAAA;uBAGA,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,wBAAA;;wBAIE,aAAA,CAAA,wBAAA;AAClB;;;;AAIG;wBACe,aAAA,CAAA,wBAAA;;uBAKD,aAAA,CAAA,wBAAA;;0BAMG,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEpB;AACA;AACA;AAEA;AACA;AAGA;AAGA;AAGA;AACA;;AAKA;AACA;;;2BAIqB,aAAA,CAAA,MAAA,CAAA,YAAA;8BAGG,aAAA,CAAA,MAAA,CAAA,eAAA;2BACH,aAAA,CAAA,MAAA;AACrB;;;AAGG;6BACoB,aAAA,CAAA,MAAA,CAAA,cAAA;+BAGE,aAAA,CAAA,MAAA;+BAGA,aAAA,CAAA,MAAA;8BAMD,aAAA,CAAA,MAAA;AAExB,kCAA4B,aAAA,CAAA,MAAA;AAG5B,oCAA8B,aAAA,CAAA,MAAA;AAI9B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,0CAAoC,aAAA,CAAA,MAAA;AAGpC,0CAAoC,aAAA,CAAA,MAAA;AAIpC,2CAAqC,aAAA,CAAA,MAAA;AAIrC;;AA2BA;;;;AAIG;;;2BAQoB,mBAAmB;AAI1C;;AASA;;AAQA,6BAAyB,KAAK;AAoB9B;oDAhNW,UAAU;sDAAV,UAAU;AAmNtB;;","names":[]}

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

@@ -0,0 +1,26 @@
+import * as _angular_core from '@angular/core';
+import { Scheme, Density } from '@slotted/theme';
+import { SeedName } from '@slotted/theme/seeds';
+
+/** The five seeds a theme derives its colours from (`@slotted/theme` › `SEED_NAMES`). */
+type ThemeSeedName = SeedName;
+/** A recipe scheme (`@slotted/theme` › `Scheme`), plus `system`: resolved from `prefers-color-scheme`. */
+type ThemeSchemeName = Scheme | 'system';
+type ThemeDensityName = Density;
+/**
+ * A subtree with its own theme, scheme, density or seeds, written on the host
+ * as the attributes and custom properties an application can write by hand.
+ */
+declare class SlThemeScope {
+    readonly theme: _angular_core.InputSignal<string | undefined>;
+    readonly scheme: _angular_core.InputSignal<ThemeSchemeName | undefined>;
+    readonly density: _angular_core.InputSignal<"comfortable" | "compact" | "dense" | undefined>;
+    readonly seeds: _angular_core.InputSignal<Readonly<Partial<Record<"accent" | "neutral" | "success" | "warning" | "danger", string>>> | undefined>;
+    protected readonly seedProperties: _angular_core.Signal<Record<string, string> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlThemeScope, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlThemeScope, "[slThemeScope]", never, { "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "scheme": { "alias": "scheme"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "seeds": { "alias": "seeds"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SlThemeScope };
+export type { ThemeDensityName, ThemeSchemeName, ThemeSeedName };
+//# sourceMappingURL=slotted-angular-theme.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-theme.d.ts","sources":["../../theme/src/theme-scope.ts"],"mappings":";;;;AAIA;AACM,KAAM,aAAa,GAAG,QAAQ;AACpC;KACY,eAAe,GAAG,MAAM;AAC9B,KAAM,gBAAgB,GAAG,OAAO;AAEtC;;;AAGG;AACH,cAUa,YAAY;oBACT,aAAA,CAAA,WAAA;qBACC,aAAA,CAAA,WAAA,CAAA,eAAA;sBACC,aAAA,CAAA,WAAA;oBACF,aAAA,CAAA,WAAA,CAAA,QAAA,CAAA,OAAA,CAAA,MAAA;AAEd,uCAAiC,aAAA,CAAA,MAAA,CAAA,MAAA;oDANtB,YAAY;sDAAZ,YAAY;AAUxB;;","names":[]}

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

@@ -0,0 +1,300 @@
+import * as _slotted_core_date from '@slotted/core/date';
+import { TimeGranularity, PlainTime, SegmentState, TimeFieldName } from '@slotted/core/date';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TimeFieldMessages } 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 TimeFieldSize = 'sm' | 'md' | 'lg';
+/**
+ * How much frame the control shows. The three steps `text-field` set, so a form
+ * holding a name and a time shows one frame twice rather than two frames.
+ */
+type TimeFieldVariant = '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 TimeFieldHourCycle = 12 | 24;
+interface TimeFieldDefaults {
+    granularity: TimeGranularity;
+    /** Unset means the locale decides both the cycle and its variant. */
+    hourCycle: TimeFieldHourCycle | undefined;
+    /** Whether `+`, `-` and `=` open the duration expression. */
+    relative: boolean;
+    size: TimeFieldSize;
+    /** Which zone answers "what time is it now". Unset means the runtime's own. */
+    timeZone: string | undefined;
+    variant: TimeFieldVariant;
+}
+declare const TIME_FIELD_DEFAULTS: InjectionToken<TimeFieldDefaults>;
+/**
+ * An application decides once what its times 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 the times, and the words, come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideTimeFieldDefaults(defaults: Partial<TimeFieldDefaults>): {
+    provide: InjectionToken<TimeFieldDefaults>;
+    useFactory: () => TimeFieldDefaults;
+};
+/** What a time field renders as here, before it states anything of its own. */
+declare function injectTimeFieldDefaults(): TimeFieldDefaults;
+
+/**
+ * What a request carries beyond the value: the segments, so a half-typed time
+ * can be saved, and whether the duration that produced it ran past midnight.
+ */
+interface TimeFieldChangeRequest extends ChangeRequest<PlainTime | null> {
+    readonly segments: SegmentState;
+    readonly crossesMidnight: boolean;
+}
+/**
+ * A segmented time control: one spin button per field, in the order the locale
+ * writes them.
+ *
+ * **The frame is not the control.** The element carrying `data-ui` is the
+ * consumer's own box with no role; `role="group"` is on the row of segments,
+ * which is what the APG's spin-button example names.
+ *
+ * **Angular is a component with a template and a `ControlValueAccessor`**,
+ * because a time belongs in a Reactive Form and Angular has the integration
+ * point for it. It also implements `Validator`: `min`, `max` and
+ * `isTimeUnavailable` are validity this control owns and no other validator can
+ * see. React has no equivalent, and `references/frameworks.md` asks for that
+ * asymmetry to be recorded rather than levelled away.
+ *
+ * **A time can be written as a duration.** `+`, `-` and `=` open one expression
+ * region in place of the segments, and what it resolves to is drawn beside it
+ * before `Enter` commits anything.
+ */
+declare class SlTimeField implements ControlValueAccessor, Validator, OnInit {
+    /** Present means the consumer owns the value. */
+    readonly value: _angular_core.InputSignal<PlainTime | null | undefined>;
+    /** The value the control starts from when nobody else writes one. */
+    readonly defaultValue: _angular_core.InputSignal<PlainTime | null | undefined>;
+    /** The earliest time the control accepts. Also a form validity rule. */
+    readonly min: _angular_core.InputSignal<PlainTime | undefined>;
+    /** The latest time the control accepts. Also a form validity rule. */
+    readonly max: _angular_core.InputSignal<PlainTime | undefined>;
+    /** Refuses particular times — a lunch break, a booked slot, a closed shop. */
+    readonly isTimeUnavailable: _angular_core.InputSignal<((time: PlainTime) => boolean) | undefined>;
+    /**
+     * BCP 47. Decides the field order, the separators and the placeholder.
+     * Unset, the language in force (`provideSlotted`) decides.
+     */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Which zone answers "what time is it now", and nothing else. */
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly hourCycle: _angular_core.InputSignal<TimeFieldHourCycle | undefined>;
+    readonly granularity: _angular_core.InputSignal<TimeGranularity | undefined>;
+    /**
+     * What an empty segment steps from, and what a duration resolves against.
+     * Unset, both are the current time in `timeZone`.
+     */
+    readonly referenceTime: _angular_core.InputSignal<PlainTime | undefined>;
+    readonly size: _angular_core.InputSignal<TimeFieldSize | undefined>;
+    readonly variant: _angular_core.InputSignal<TimeFieldVariant | 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 the value 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, the duration region's name and the next-day preview.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TimeFieldMessages> | undefined>;
+    /** The name a plain form post carries the `HH:mm:ss` string under. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * One output for one transition, carrying the value, the value it replaces,
+     * the segments, whether a duration crossed midnight, 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 — `time-range-picker` names its two ends — has no
+     * static attribute to write.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<TimeFieldChangeRequest>;
+    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<TimeFieldMessages>;
+    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 time 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 time an empty segment steps to and a duration resolves from.
+     */
+    private readonly clock;
+    protected readonly activeField: _angular_core.WritableSignal<TimeFieldName | 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 format: _angular_core.Signal<_slotted_core_date.TimeFormat>;
+    protected readonly dataCycle: _angular_core.Signal<"12" | "24">;
+    protected readonly fields: _angular_core.Signal<TimeFieldName[]>;
+    /** What an empty segment steps from, in the shape the engine reads. */
+    private readonly reference;
+    private readonly anchor;
+    /** The time the segments make, or `null` while any drawn field is unfilled. */
+    readonly time: _angular_core.Signal<PlainTime | null>;
+    protected readonly iso: _angular_core.Signal<string>;
+    protected readonly spokenTime: _angular_core.Signal<string>;
+    protected readonly resolved: _angular_core.Signal<_slotted_core_date.TimeStep | null>;
+    protected readonly crossesMidnight: _angular_core.Signal<boolean>;
+    protected readonly previewText: _angular_core.Signal<string>;
+    readonly resolvedSize: _angular_core.Signal<TimeFieldSize>;
+    readonly resolvedVariant: _angular_core.Signal<TimeFieldVariant>;
+    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. A time
+     * outside the bounds or refused by the predicate is invalid whatever the
+     * field around it says, because this control is the only thing that knows.
+     */
+    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: PlainTime | null | undefined): void;
+    registerOnChange(fn: (value: PlainTime | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnValidatorChange(fn: () => void): void;
+    /**
+     * The rules no other validator can see. `required` 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 time when none is. Every text
+     * control on the page answers a press anywhere inside its border.
+     */
+    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 every segment, 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 time, 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 `+40m` does what typing it does.
+     */
+    protected onPaste(event: ClipboardEvent): void;
+    /** A run of typed digits ends when focus leaves. */
+    protected onBlur(): void;
+    protected valueOf(field: TimeFieldName): number | null;
+    protected rangeOf(field: TimeFieldName): {
+        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.
+     */
+    protected spokenOf(field: TimeFieldName): 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: TimeFieldName): string;
+    /** Exactly one segment is in the tab sequence, which is the roving model. */
+    protected tabIndexOf(field: TimeFieldName): number;
+    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<SlTimeField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimeField, "[slTimeField]", ["slTimeField"], { "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; }; "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; }; "referenceTime": { "alias": "referenceTime"; "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, ["[slTimeFieldStart]", "[slTimeFieldEnd]"], true, never>;
+}
+
+/**
+ * An adornment before the time in the reading direction: a clock mark, a label,
+ * an icon. Named for the direction rather than for a side, so the same markup
+ * puts the mark before the time 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 SlTimeFieldStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeFieldStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeFieldStart, "[slTimeFieldStart]", ["slTimeFieldStart"], {}, {}, never, never, true, never>;
+}
+/** An adornment after the time in the reading direction. */
+declare class SlTimeFieldEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeFieldEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeFieldEnd, "[slTimeFieldEnd]", ["slTimeFieldEnd"], {}, {}, never, never, true, never>;
+}
+
+export { SlTimeField, SlTimeFieldEnd, SlTimeFieldStart, TIME_FIELD_DEFAULTS, injectTimeFieldDefaults, provideTimeFieldDefaults };
+export type { TimeFieldChangeRequest, TimeFieldDefaults, TimeFieldHourCycle, TimeFieldSize, TimeFieldVariant };
+//# sourceMappingURL=slotted-angular-time-field.d.ts.map

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

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