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

package/types/slotted-angular-otp-input.d.ts

@@ -0,0 +1,286 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, OnInit } from '@angular/core';
+import { OtpType, OtpSelection } from '@slotted/core/otp';
+export { OtpType as OtpInputType } from '@slotted/core/otp';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** The type step the control sits at, matching the field around it. */
+type OtpInputSize = 'sm' | 'md' | 'lg';
+/**
+ * How much frame each box shows. `outline` takes the ground it is placed on
+ * and `subtle` sinks into the page — the two steps `text-field` draws. There
+ * is no `plain`: a code is never a cell.
+ */
+type OtpInputVariant = 'outline' | 'subtle';
+
+interface OtpInputDefaults {
+    attached: boolean;
+    length: number;
+    placeholder: string;
+    size: OtpInputSize;
+    type: OtpType;
+    variant: OtpInputVariant;
+}
+declare const OTP_INPUT_DEFAULTS: InjectionToken<OtpInputDefaults>;
+/**
+ * An application decides once what its code fields look like — and how long
+ * its codes are — rather than repeating the same inputs on every verification
+ * screen. A control that states any of them itself still wins.
+ *
+ * `size` is the one the field outranks: a control inside a field takes the
+ * field's step and this token answers only outside one.
+ */
+declare function provideOtpInputDefaults(defaults: Partial<OtpInputDefaults>): {
+    provide: InjectionToken<OtpInputDefaults>;
+    useFactory: () => OtpInputDefaults;
+};
+/** What a code field renders as here, before it states anything of its own. */
+declare function injectOtpInputDefaults(): OtpInputDefaults;
+/**
+ * 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 `text-field` already has.
+ * The control provides itself as this, and the frame queries for it.
+ */
+declare abstract class SlOtpInputState {
+    /** The characters the element holds, cut to the code. */
+    abstract readonly code: Signal<string>;
+    /** Where the cursor or the selection is, while the control has focus. */
+    abstract readonly selection: Signal<OtpSelection | null>;
+    abstract readonly focused: Signal<boolean>;
+    abstract readonly resolvedDisabled: Signal<boolean | undefined>;
+    abstract readonly resolvedReadOnly: Signal<boolean | undefined>;
+    abstract readonly resolvedInvalid: Signal<boolean | undefined>;
+    /** Puts the cursor in the box at `index`, clamped to the value. */
+    abstract pressAt(index: number): void;
+}
+
+interface Slot {
+    readonly index: number;
+    readonly shown: string;
+    readonly placeholder: string;
+    readonly current: boolean;
+}
+/**
+ * The frame: N painted boxes around one real input.
+ *
+ * **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 every native attribute, and lies over the boxes, transparent. The boxes
+ * are drawn here from what the control reports, and are hidden from assistive
+ * technology.
+ *
+ * **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. `slOtpInputControl` injects this class, so a
+ * control written without the frame is a compile-time failure rather than a
+ * silent one.
+ */
+declare class SlOtpInput {
+    /** Defaults to the field, then to the token, then to `md`. */
+    readonly size: _angular_core.InputSignal<OtpInputSize | undefined>;
+    /** Defaults to the token, then to `outline`. */
+    readonly variant: _angular_core.InputSignal<OtpInputVariant | undefined>;
+    /** Joins the boxes of a group along one seam. Defaults to the token's. */
+    readonly attached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** How many characters the code has. Defaults to the token's, then 6. */
+    readonly length: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * How the boxes are partitioned: `[3, 3]` draws two groups of three with a
+     * separator between them. The sum has to be `length`; a partition that does
+     * not add up draws one group.
+     */
+    readonly groupsInput: _angular_core.InputSignal<readonly number[] | undefined>;
+    /**
+     * What an empty box shows: one character repeats over every box, and a
+     * string as long as the code distributes. Defaults to the token's.
+     */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Hides the characters: the control becomes `type="password"`, so the
+     * platform treats the value as a secret, and each filled box shows a bullet.
+     */
+    readonly mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly defaults;
+    private readonly field;
+    /**
+     * The control inside. It provides itself as `SlOtpInputState`, so the frame
+     * can paint the value and the cursor without either directive importing the
+     * other.
+     */
+    readonly control: _angular_core.Signal<SlOtpInputState | undefined>;
+    readonly resolvedSize: _angular_core.Signal<OtpInputSize>;
+    readonly resolvedVariant: _angular_core.Signal<OtpInputVariant>;
+    readonly resolvedAttached: _angular_core.Signal<boolean>;
+    readonly resolvedLength: _angular_core.Signal<number>;
+    readonly resolvedPlaceholder: _angular_core.Signal<string>;
+    readonly complete: _angular_core.Signal<boolean>;
+    protected readonly groups: _angular_core.Signal<Slot[][]>;
+    /**
+     * A press on a box puts the cursor in that box. The input lies over the
+     * boxes and would otherwise place its caret by the x of transparent text;
+     * the box under the pointer is what the reader meant, so it is found from
+     * the point and handed to the control.
+     */
+    protected onPointerDown(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlOtpInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlOtpInput, "[slOtpInput]", ["slOtpInput"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "groupsInput": { "alias": "groups"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; }, {}, ["control"], ["*"], true, never>;
+}
+
+/** What an edit lost to the filter, and the event that carried it. */
+interface OtpInputRejection {
+    readonly text: string;
+    readonly source: Event;
+}
+/**
+ * The control itself: the value, the identifier, and everything the field
+ * around it says. `dragstart` is refused: a press on a selected character
+ * would otherwise drag that text, with a ghost of the character floating
+ * under the pointer, and in a full code a character is selected at every
+ * press.
+ *
+ * **The element owns the characters, and the directive keeps a copy.** The
+ * frame paints every character, so unlike `text-field` this mirror is the
+ * value and not only its length. `writeValue` from a form and a `[value]`
+ * binding both write the element; typing writes it directly, and the copy
+ * follows — which is what Angular's own `DefaultValueAccessor` does.
+ *
+ * **The selection is normalised, not the keys.** Every key is the browser's.
+ * After each change the directive makes sure a cursor inside the value has
+ * one character selected, so typing replaces it instead of being refused by
+ * `maxlength` — the rule `@slotted/core/otp` holds.
+ *
+ * **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 SlOtpInputControl implements ControlValueAccessor, OnInit, SlOtpInputState {
+    /** 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>;
+    /** Which characters the code takes. Defaults to the token's, then `numeric`. */
+    readonly type: _angular_core.InputSignal<OtpType | undefined>;
+    /** Tested against each character; outranks `type` in what is accepted. */
+    readonly pattern: _angular_core.InputSignal<RegExp | undefined>;
+    /**
+     * Run over every edit before the filter: strip a `G-` prefix, uppercase a
+     * code the reader typed in lowercase.
+     */
+    readonly transform: _angular_core.InputSignal<((text: string) => string) | undefined>;
+    /** Unstated rather than `false`, so the control defers to the field. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Unstated rather than `false`. Reaches the element as the native `readonly`. */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Unstated rather than `false`. Reaches the element as `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Submits the owning form when the code is complete. */
+    readonly autoSubmit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Asks the platform for the code the moment an SMS arrives, where the
+     * WebOTP API exists. The request is abandoned when the form submits or the
+     * control is destroyed.
+     */
+    readonly webOtp: _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 `[(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<string>>;
+    /** The value, the moment it reaches `length` characters. */
+    readonly complete: _angular_core.OutputEmitterRef<string>;
+    /** What an edit lost to the filter, before the value moves. */
+    readonly rejected: _angular_core.OutputEmitterRef<OtpInputRejection>;
+    private readonly element;
+    private readonly destroyRef;
+    /**
+     * The frame around the control. Injected without `optional`, so an `input`
+     * written without it fails at construction rather than silently losing its
+     * boxes. It is public because the host bindings read its length and mask.
+     */
+    readonly frame: SlOtpInput;
+    private readonly field;
+    private readonly defaults;
+    private readonly writtenId;
+    private readonly writtenType;
+    private readonly writtenAutocomplete;
+    private readonly writtenInputMode;
+    private readonly writtenSpellcheck;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    private readonly writtenReadonly;
+    /** What the element is showing, cut to the code. */
+    private readonly mirror;
+    readonly code: _angular_core.Signal<string>;
+    private readonly ownSelection;
+    readonly selection: _angular_core.Signal<OtpSelection | null>;
+    private readonly ownFocused;
+    readonly focused: _angular_core.Signal<boolean>;
+    private previousSelection;
+    private reported;
+    private readonly formDisabled;
+    private onChangeFn;
+    private onTouchedFn;
+    readonly resolvedType: _angular_core.Signal<string>;
+    /** Which characters the code takes, stated here or by the token. */
+    readonly codeType: _angular_core.Signal<OtpType>;
+    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 resolvedAutocomplete: _angular_core.Signal<string>;
+    protected readonly resolvedInputMode: _angular_core.Signal<string>;
+    protected readonly resolvedSpellcheck: _angular_core.Signal<string>;
+    /** Merged after the consumer's own, so a tour step is read before the help. */
+    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.
+     */
+    ngOnInit(): void;
+    /** The native element, for `focus()`, `select()` and `setSelectionRange()`. */
+    get inputElement(): HTMLInputElement;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    pressAt(index: number): void;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    private sanitize;
+    /** Reads the element's selection, corrects it, and paints the current box. */
+    private syncSelection;
+    /**
+     * Completion is a fact about the value, reported once per value: a full
+     * code edited into another full code reports again, and a code emptied and
+     * retyped reports again.
+     */
+    private reportCompletion;
+    /**
+     * The WebOTP API: where it exists, the platform hands over the code the
+     * moment the SMS arrives. Abandoned when the form submits on its own or the
+     * directive is destroyed, which is the shape MDN's example takes.
+     */
+    private requestWebOtp;
+    /** Emits the request and says whether anything may commit. */
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlOtpInputControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlOtpInputControl, "input[slOtpInputControl]", ["slOtpInputControl"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "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; }; "autoSubmit": { "alias": "autoSubmit"; "required": false; "isSignal": true; }; "webOtp": { "alias": "webOtp"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "complete": "complete"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+export { OTP_INPUT_DEFAULTS, SlOtpInput, SlOtpInputControl, SlOtpInputState, injectOtpInputDefaults, provideOtpInputDefaults };
+export type { OtpInputDefaults, OtpInputRejection, OtpInputSize, OtpInputVariant };
+//# sourceMappingURL=slotted-angular-otp-input.d.ts.map

package/types/slotted-angular-otp-input.d.ts.map

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

package/types/slotted-angular-page-header.d.ts

@@ -0,0 +1,334 @@
+import * as _slotted_angular_page from '@slotted/angular/page';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, PageHeaderMessages } from '@slotted/core/i18n';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import * as _slotted_angular_progress_indicator from '@slotted/angular/progress-indicator';
+import { ProgressTone, ProgressSize } from '@slotted/angular/progress-indicator';
+import * as _slotted_angular_page_header from '@slotted/angular/page-header';
+
+/** The type step the title sits at. The snapped title takes the step below it. */
+type PageHeaderSize = 'sm' | 'md' | 'lg';
+/** The rank of the heading. A page's own header is `1`. */
+type PageHeaderLevel = '1' | '2' | '3';
+/**
+ * What collapses the header area. `scroll` collapses it when it leaves the
+ * scrollport and re-opens it when it returns; `manual` leaves it to the toggle,
+ * the pin and the application, and the whole header stays while the page
+ * scrolls.
+ */
+type PageHeaderCollapse = 'scroll' | 'manual';
+/**
+ * The ground and the frame. `band` is a strip of the surface with a hairline
+ * under it; `plain` paints no ground at rest and takes the surface back once
+ * content passes under it; `floating` is a box of its own, rounded, that
+ * slides to an inset below the scroller's edge once stuck.
+ */
+type PageHeaderVariant = 'band' | 'plain' | 'floating';
+/** Why the header area opened or closed. */
+type PageHeaderExpandedReason = 'pointer' | 'keyboard' | 'scroll' | 'programmatic';
+/** Why the pin took hold or let go. */
+type PageHeaderPinnedReason = 'pointer' | 'keyboard' | 'programmatic';
+interface PageHeaderDefaults {
+    collapse: PageHeaderCollapse;
+    level: PageHeaderLevel;
+    size: PageHeaderSize;
+    variant: PageHeaderVariant;
+}
+declare const PAGE_HEADER_DEFAULTS: InjectionToken<PageHeaderDefaults>;
+/**
+ * An application decides once how its page headers behave — the size, the
+ * rank, whether a scroll collapses the area — rather than repeating them on
+ * every screen. A header that states any of them itself still wins. Its words
+ * come from the language in force (`provideSlotted`).
+ */
+declare function providePageHeaderDefaults(defaults: Partial<PageHeaderDefaults>): {
+    provide: InjectionToken<PageHeaderDefaults>;
+    useFactory: () => PageHeaderDefaults;
+};
+/** What a page header renders as here, before it states anything of its own. */
+declare function injectPageHeaderDefaults(): PageHeaderDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field`
+ * records: a module-level counter produces colliding sequences when two
+ * applications render in one server process, and the server and the client
+ * sequences must match for hydration.
+ */
+declare class SlPageHeaderIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderIdFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * The shell of a screen's top: a title area that never leaves, a header area
+ * that scrolls away under it and comes back, a pill of controls on the
+ * chrome's edge, and a slot for tabs. SAP Fiori's Dynamic Page, rebuilt on one
+ * sticky root.
+ *
+ * **The stylesheet does the moving.** The root is `position: sticky` with a
+ * negative offset the size of the header area, measured into
+ * `--slotted-page-header-collapse` by `@slotted/core/sticky-header`, which
+ * the React binding drives the same way. Scrolling takes the area under the
+ * title and leaves the title where it is.
+ *
+ * **Two values a template may bind.** `expanded` moves by the toggle, by the
+ * pin, by the application and by the scroll; `pinned` by the pin and the
+ * application. Each move is first a request on `expandedRequest` or
+ * `pinnedRequest`, carrying the reason — `scroll` is a reason of its own — and
+ * `cancel()`.
+ */
+declare class SlPageHeader {
+    /** Whether the header area is open. Two-way, so a template may bind it directly. */
+    readonly expanded: i0.ModelSignal<boolean>;
+    /** Whether the pin holds the area open. Two-way. */
+    readonly pinned: i0.ModelSignal<boolean>;
+    readonly variant: i0.InputSignal<PageHeaderVariant | undefined>;
+    readonly size: i0.InputSignal<PageHeaderSize | undefined>;
+    readonly level: i0.InputSignal<PageHeaderLevel | undefined>;
+    readonly collapse: i0.InputSignal<PageHeaderCollapse | undefined>;
+    /**
+     * Whether the title has not arrived yet. The heading, the subheading and the
+     * description render `slSkeletonText` in place of their words; the actions
+     * stay operable; the root carries `aria-busy`.
+     */
+    readonly loading: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * toggle, the pin and the header area's name. A static `aria-label` on a
+     * part still wins.
+     */
+    readonly messages: i0.InputSignal<PartialMessages<PageHeaderMessages> | undefined>;
+    /** One output for one transition of the header area, carrying the reason and the event. */
+    readonly expandedRequest: i0.OutputEmitterRef<ChangeRequest<boolean>>;
+    /** One output for one transition of the pin, carrying the reason and the event. */
+    readonly pinnedRequest: i0.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly defaults;
+    private readonly page;
+    private readonly native;
+    private readonly generated;
+    readonly resolvedVariant: i0.Signal<PageHeaderVariant>;
+    readonly resolvedSize: i0.Signal<PageHeaderSize>;
+    readonly resolvedLevel: i0.Signal<PageHeaderLevel>;
+    readonly resolvedCollapse: i0.Signal<PageHeaderCollapse>;
+    /** The family's words in the language in force, with this header's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<PageHeaderMessages>;
+    protected readonly containerSize: i0.Signal<_slotted_angular_page.PageWidth>;
+    protected readonly containerInset: i0.Signal<_slotted_angular_page.PageInset | undefined>;
+    /** Whether the scroll has passed the area — a measured fact. */
+    readonly scrolled: i0.WritableSignal<boolean>;
+    /** The header is too much of the screen to hold; the pin is hidden and a held header let go. */
+    readonly tall: i0.WritableSignal<boolean>;
+    /** The header is narrower than the compact size class; it is in the flow and nothing condenses it. */
+    readonly compact: i0.WritableSignal<boolean>;
+    /** Whether the area is shown whole in place although the scroll has passed it. */
+    readonly revealed: i0.WritableSignal<boolean>;
+    /** Whether content passes under the chrome — a measured fact `plain` and `floating` read. */
+    readonly stuck: i0.WritableSignal<boolean>;
+    private engine;
+    /** Who asked for the move the next change detection will show. */
+    private expandedBy;
+    /** The identifiers that wire the toggle to the area and the root to its heading. */
+    ids(): {
+        areaId: string;
+        headingId: string;
+    };
+    constructor();
+    /**
+     * The body of the page this header heads, while that page fills: nothing
+     * scrolls outside it there, so its principal scroller is what snaps the area.
+     * Read from the DOM on every scroll, so a page that turns `fill` on or off
+     * is followed without rebuilding the engine.
+     */
+    private filledBody;
+    private request;
+    private requestPinned;
+    /** Asks the header area to open or close, carrying the reason and the originating event. */
+    setExpanded(next: boolean, reason: PageHeaderExpandedReason, source?: Event): void;
+    /** Asks the pin to take hold or let go, carrying the reason and the originating event. */
+    setPinned(next: boolean, reason: PageHeaderPinnedReason, source?: Event): void;
+    /** Opens the header area, carrying `programmatic`. Scrolled past, it reveals it in place. */
+    expand(): void;
+    /** Closes the header area, carrying `programmatic`. */
+    collapseArea(): void;
+    /** Takes hold, carrying `programmatic`; a collapsed area opens with it. */
+    pin(): void;
+    /** Lets go, carrying `programmatic`. */
+    unpin(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeader, "[slPageHeader]", ["slPageHeader"], { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "pinned": { "alias": "pinned"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "pinned": "pinnedChange"; "expandedRequest": "expandedRequest"; "pinnedRequest": "pinnedRequest"; }, never, ["*"], true, never>;
+}
+
+/** The strip that never leaves: nav, title row and controls. Sticky at 0 inside the root. */
+declare class SlPageHeaderTitleArea {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderTitleArea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderTitleArea, "[slPageHeaderTitleArea]", never, {}, {}, never, never, true, never>;
+}
+/** The row above the title: the way back, then the breadcrumbs. */
+declare class SlPageHeaderNav {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderNav, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderNav, "[slPageHeaderNav]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The way back: the consumer's own link or button, with the arrow the family
+ * draws before it. The arrow points along the reading direction and mirrors
+ * with it.
+ */
+declare class SlPageHeaderBack {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderBack, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderBack, "[slPageHeaderBack]", never, {}, {}, never, ["*"], true, never>;
+}
+/** The slot a breadcrumb sits in. Hidden below 600 pixels. */
+declare class SlPageHeaderBreadcrumbs {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderBreadcrumbs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderBreadcrumbs, "[slPageHeaderBreadcrumbs]", never, {}, {}, never, never, true, never>;
+}
+/** Visual, title, actions and navigation, on one row that wraps. */
+declare class SlPageHeaderTitleRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderTitleRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderTitleRow, "[slPageHeaderTitleRow]", never, {}, {}, never, never, true, never>;
+}
+/** The mark before the heading: an avatar, an icon, an image. */
+declare class SlPageHeaderVisual {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderVisual, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderVisual, "[slPageHeaderVisual]", never, {}, {}, never, never, true, never>;
+}
+/** The column of heading, marks and subheading. */
+declare class SlPageHeaderTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderTitle, "[slPageHeaderTitle]", never, {}, {}, never, never, true, never>;
+}
+/** The status beside the heading: a tag, a badge, a status indicator. */
+declare class SlPageHeaderMarks {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderMarks, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderMarks, "[slPageHeaderMarks]", never, {}, {}, never, never, true, never>;
+}
+/** The slot a toolbar sits in, pushed to the end of the title row. */
+declare class SlPageHeaderActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderActions, "[slPageHeaderActions]", never, {}, {}, never, never, true, never>;
+}
+/** The previous and next record, at the far end of the title row. */
+declare class SlPageHeaderNavigation {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderNavigation, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderNavigation, "[slPageHeaderNavigation]", never, {}, {}, never, never, true, never>;
+}
+/** The picture of the record, a column before the content of the header area. */
+declare class SlPageHeaderFigure {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderFigure, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderFigure, "[slPageHeaderFigure]", never, {}, {}, never, never, true, never>;
+}
+/** A column of whatever only makes sense at rest. */
+declare class SlPageHeaderContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderContent, "[slPageHeaderContent]", never, {}, {}, never, never, true, never>;
+}
+/** The slot a tabs family sits in, last in the root. */
+declare class SlPageHeaderTabs {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderTabs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderTabs, "[slPageHeaderTabs]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The heading. The element is the consumer's own: `<h1 slPageHeaderHeading>`
+ * is a native heading and this adds nothing to it, while a `div` or an
+ * `input` gets `role="heading"` and the level the header resolved. While
+ * loading it renders `slSkeletonText` in place of its words.
+ */
+declare class SlPageHeaderHeading {
+    protected readonly header: SlPageHeader;
+    private readonly native;
+    private readonly isNativeHeading;
+    protected readonly ariaRole: i0.Signal<"heading" | null>;
+    protected readonly ariaLevel: i0.Signal<_slotted_angular_page_header.PageHeaderLevel | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderHeading, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderHeading, "[slPageHeaderHeading]", ["slPageHeaderHeading"], {}, {}, never, ["*"], true, never>;
+}
+/** One line under the heading, in the muted text, part of what stays visible. */
+declare class SlPageHeaderSubheading {
+    protected readonly header: SlPageHeader;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderSubheading, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderSubheading, "[slPageHeaderSubheading]", never, {}, {}, never, ["*"], true, never>;
+}
+/** A paragraph with a measure, inside the header area's content. */
+declare class SlPageHeaderDescription {
+    protected readonly header: SlPageHeader;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderDescription, "[slPageHeaderDescription]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The region that collapses. Collapsed by the control it is `inert` and
+ * hidden from assistive technology; scrolled past it is neither, so a control
+ * inside it that receives focus is scrolled back into view and the header
+ * re-opens with the reason `scroll`.
+ */
+declare class SlPageHeaderArea {
+    protected readonly header: SlPageHeader;
+    private readonly written;
+    private readonly native;
+    protected readonly label: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderArea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlPageHeaderArea, "[slPageHeaderArea]", ["slPageHeaderArea"], {}, {}, never, never, true, never>;
+}
+/** The zero-height row on the chrome's edge; the pill is its only child. */
+declare class SlPageHeaderControls {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderControls, "[slPageHeaderControls]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The disclosure control: the consumer's own `button`, so `Enter` and `Space`
+ * are the platform's. `aria-expanded` and `aria-controls` are the pattern's
+ * two properties.
+ */
+declare class SlPageHeaderToggle {
+    protected readonly header: SlPageHeader;
+    private readonly written;
+    protected readonly label: i0.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderToggle, "button[slPageHeaderToggle]", ["slPageHeaderToggle"], {}, {}, never, ["*"], true, never>;
+}
+/** The pin: a toggle button with `aria-pressed`, which is the `pressed` state the vocabulary has. */
+declare class SlPageHeaderPin {
+    protected readonly header: SlPageHeader;
+    private readonly written;
+    protected readonly label: i0.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderPin, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderPin, "button[slPageHeaderPin]", ["slPageHeaderPin"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * A refresh of what is already on screen, drawn over the line where the chrome
+ * ends. Written after the controls and before the tabs, as the controls are:
+ * there it is the line the pill straddles, and with no tabs it is the root's
+ * own hairline. The frame is a row of the container one hairline tall; the
+ * stylesheet gives the bar the header's width and draws nothing while the
+ * title is still loading or while a region around the header is busy. `size`
+ * defaults to `sm`, `delay` to 200 and `minDuration` to 400 milliseconds; an
+ * input, then `provideProgressIndicatorDefaults()`, wins.
+ */
+declare class SlPageHeaderProgress {
+    protected readonly header: SlPageHeader;
+    protected readonly defaults: _slotted_angular_progress_indicator.ProgressIndicatorDefaults;
+    readonly loading: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly value: i0.InputSignal<number | null | undefined>;
+    readonly min: i0.InputSignal<number | undefined>;
+    readonly max: i0.InputSignal<number | undefined>;
+    readonly buffer: i0.InputSignal<number | null | undefined>;
+    readonly valueText: i0.InputSignal<string | undefined>;
+    readonly label: i0.InputSignal<string | undefined>;
+    readonly tone: i0.InputSignal<ProgressTone | undefined>;
+    readonly size: i0.InputSignal<ProgressSize | undefined>;
+    readonly delay: i0.InputSignal<number | undefined>;
+    readonly minDuration: i0.InputSignal<number | undefined>;
+    /** The bar was painted and has been withdrawn. */
+    readonly withdraw: i0.OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlPageHeaderProgress, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlPageHeaderProgress, "[slPageHeaderProgress]", ["slPageHeaderProgress"], { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "minDuration": { "alias": "minDuration"; "required": false; "isSignal": true; }; }, { "withdraw": "withdraw"; }, never, never, true, never>;
+}
+
+export { PAGE_HEADER_DEFAULTS, SlPageHeader, SlPageHeaderActions, SlPageHeaderArea, SlPageHeaderBack, SlPageHeaderBreadcrumbs, SlPageHeaderContent, SlPageHeaderControls, SlPageHeaderDescription, SlPageHeaderFigure, SlPageHeaderHeading, SlPageHeaderIdFactory, SlPageHeaderMarks, SlPageHeaderNav, SlPageHeaderNavigation, SlPageHeaderPin, SlPageHeaderProgress, SlPageHeaderSubheading, SlPageHeaderTabs, SlPageHeaderTitle, SlPageHeaderTitleArea, SlPageHeaderTitleRow, SlPageHeaderToggle, SlPageHeaderVisual, injectPageHeaderDefaults, providePageHeaderDefaults };
+export type { PageHeaderCollapse, PageHeaderDefaults, PageHeaderExpandedReason, PageHeaderLevel, PageHeaderPinnedReason, PageHeaderSize, PageHeaderVariant };
+//# sourceMappingURL=slotted-angular-page-header.d.ts.map

package/types/slotted-angular-page-header.d.ts.map

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