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

package/types/slotted-angular-import-export-center.d.ts

@@ -0,0 +1,351 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, ImportExportCenterMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, Signal } from '@angular/core';
+import { GlyphName } from '@slotted/angular/icon';
+import { JobFileRole, ImportExportJob, JobControls, JobFile } from '@slotted/core/import-export-center';
+export { ImportExportJob, JobCounts, JobDirection, JobFile, JobFileRole, JobProgress, JobRowError, JobStatus } from '@slotted/core/import-export-center';
+import { ChangeRequest } from '@slotted/core/state';
+import { FormattedTimestamp } from '@slotted/core/timeline';
+import { FileKind } from '@slotted/core/upload';
+import * as i1 from '@slotted/angular/tooltip';
+import { ToastMessage, ToastContent } from '@slotted/angular/toast';
+
+type ImportExportCenterSize = 'sm' | 'md';
+type ImportExportCenterLevel = '2' | '3' | '4';
+type ImportExportCenterGrowing = 'none' | 'button';
+type ImportExportCenterTimeFormat = 'relative' | 'absolute';
+type ImportExportCenterStatus = 'ready' | 'error';
+/** A press on one of the family's own controls: a pointer, or a key on a focused control. */
+type ImportExportPressReason = 'pointer' | 'keyboard';
+type ImportExportRemoveReason = ImportExportPressReason | 'clear';
+/**
+ * A request over one of the consumer's facts, carrying the reason and the
+ * originating event; `cancel()` refuses it, and a cancelled download or open
+ * does not navigate.
+ */
+interface ImportExportRequest<Reason extends string> {
+    readonly reason: Reason;
+    readonly event?: Event | undefined;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+interface ImportExportJobRequest extends ImportExportRequest<ImportExportPressReason> {
+    readonly key: string;
+}
+interface ImportExportRemoveRequest extends ImportExportRequest<ImportExportRemoveReason> {
+    readonly keys: readonly string[];
+}
+interface ImportExportDownloadRequest extends ImportExportRequest<ImportExportPressReason> {
+    readonly key: string;
+    /** Which of the job's files: the original, the result, or the report of failed rows. */
+    readonly file: JobFileRole;
+}
+interface ImportExportView {
+    readonly value: string;
+    readonly label: string;
+}
+interface ImportExportCenterDefaults {
+    growing: ImportExportCenterGrowing;
+    level: ImportExportCenterLevel;
+    size: ImportExportCenterSize;
+    timeFormat: ImportExportCenterTimeFormat;
+    timeZone?: string | undefined;
+}
+declare const IMPORT_EXPORT_CENTER_DEFAULTS: InjectionToken<ImportExportCenterDefaults>;
+/**
+ * An application decides once how its job centre reads — the size, the rank,
+ * how history loads, how time is written and in which zone. A centre that
+ * states any of them still wins. Its words and the locale come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideImportExportCenterDefaults(defaults: Partial<ImportExportCenterDefaults>): {
+    provide: InjectionToken<ImportExportCenterDefaults>;
+    useFactory: () => ImportExportCenterDefaults;
+};
+declare function injectImportExportCenterDefaults(): ImportExportCenterDefaults;
+declare class SlImportExportCenterIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportCenterIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** A click with no coordinates is a key. */
+declare function pressReason(event: Event): ImportExportPressReason;
+/** What a job's own actions template is handed. */
+interface ImportExportJobContext {
+    $implicit: ImportExportJob;
+}
+/** One row of a job's files, resolved for the template. */
+interface FileRow {
+    role: JobFileRole;
+    label: string;
+    file: JobFile;
+    stem: string;
+    extension: string;
+    size: string | null;
+    note: string | null;
+    downloadable: boolean;
+    availability: string;
+}
+/** Everything the template draws for one job, resolved once per render. */
+interface JobView {
+    job: ImportExportJob;
+    ids: {
+        title: string;
+        status: string;
+        toggle: string;
+        details: string;
+        control: (part: string) => string;
+    };
+    outcome: string | null;
+    controls: JobControls;
+    ordered: readonly string[];
+    removable: boolean;
+    expanded: boolean;
+    kind: FileKind;
+    kindGlyph: GlyphName;
+    directionText: string;
+    mark: GlyphName | 'spinner';
+    file: {
+        stem: string;
+        extension: string;
+        size: string | null;
+    } | null;
+    time: FormattedTimestamp | null;
+    statusText: string;
+    progressText: readonly string[];
+    summary: readonly string[];
+    message: string | null;
+    downloadFile: JobFile | null;
+    downloadLabel: string;
+    retryLabel: string;
+    counts: readonly {
+        key: string;
+        label: string;
+        value: string;
+    }[];
+    files: readonly FileRow[];
+    errorNote: string | null;
+}
+/**
+ * The consumer's own controls for one job, after the family's.
+ *
+ * ```html
+ * <ng-template slImportExportJobActions let-job>
+ *   <a slButtonLink size="sm" variant="ghost" [href]="'/jobs/' + job.key">Abrir</a>
+ * </ng-template>
+ * ```
+ */
+declare class SlImportExportJobActions {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportJobActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImportExportJobActions, "ng-template[slImportExportJobActions]", never, {}, {}, never, never, true, never>;
+}
+/** The consumer's controls in the header: an import dialog's trigger, an export button. */
+declare class SlImportExportCenterActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportCenterActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImportExportCenterActions, "[slImportExportCenterActions]", never, {}, {}, never, never, true, never>;
+}
+/** Replaces the view's empty page. */
+declare class SlImportExportCenterEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportCenterEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImportExportCenterEmpty, "[slImportExportCenterEmpty]", never, {}, {}, never, never, true, never>;
+}
+/** The consumer's footer: the link from a popover to the whole page. */
+declare class SlImportExportCenterFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportCenterFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImportExportCenterFooter, "[slImportExportCenterFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The jobs an application runs away from the page — imports and exports —
+ * and what the reader can do about each.
+ *
+ * **It holds none of the facts.** `jobs` is the consumer's array. Cancelling,
+ * retrying, removing, downloading, opening and loading are outputs with a
+ * reason, and the store answers by changing the array. The family never
+ * opens a connection and never transfers a byte: `upload` does, in the
+ * import dialog the consumer projects into the actions slot.
+ *
+ * **Two values move:** `[(view)]` and `[(expanded)]`, each with a request
+ * output that carries the reason and can be cancelled.
+ *
+ * **What a job offers is one table,** `jobControls` in
+ * `@slotted/core/import-export-center`, which the React binding renders too.
+ *
+ * **Focus never falls to the body.** A job that finishes while focus is on
+ * Cancel keeps focus in the job; a job that leaves takes focus to the same
+ * control of the job in its place.
+ */
+declare class SlImportExportCenter {
+    /** The consumer's jobs, in the order they are drawn. The family changes none of them. */
+    readonly jobs: _angular_core.InputSignal<readonly ImportExportJob[]>;
+    /** The strip's entries. `all`, `import` and `export` when unstated; one entry draws no strip. */
+    readonly views: _angular_core.InputSignal<readonly ImportExportView[] | undefined>;
+    readonly size: _angular_core.InputSignal<ImportExportCenterSize | undefined>;
+    readonly level: _angular_core.InputSignal<ImportExportCenterLevel | undefined>;
+    readonly growing: _angular_core.InputSignal<ImportExportCenterGrowing | undefined>;
+    readonly timeFormat: _angular_core.InputSignal<ImportExportCenterTimeFormat | undefined>;
+    /** What numbers, sizes, times and deadlines are written in. Absent, the language in force. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    /** The moment a relative reading and a deadline count from. State it for a stable server render. */
+    readonly now: _angular_core.InputSignal<number | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly status: _angular_core.InputSignal<ImportExportCenterStatus>;
+    /** Whether the history has another page; `growing="button"` draws `more` while it has. */
+    readonly hasMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Words laid over the catalog of the language in force, key by key. */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ImportExportCenterMessages> | undefined>;
+    /** The view an unbound centre starts on, read once. */
+    readonly defaultView: _angular_core.InputSignal<string | undefined>;
+    /** The keys an unbound centre starts with shown, read once. */
+    readonly defaultExpanded: _angular_core.InputSignal<readonly string[] | undefined>;
+    /** The current view. Two-way. */
+    readonly view: _angular_core.ModelSignal<string | undefined>;
+    /** The keys whose details are shown. Two-way. */
+    readonly expanded: _angular_core.ModelSignal<readonly string[] | undefined>;
+    readonly viewRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | undefined>>;
+    readonly expandedRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[] | undefined>>;
+    readonly cancelRequest: _angular_core.OutputEmitterRef<ImportExportJobRequest>;
+    readonly retryRequest: _angular_core.OutputEmitterRef<ImportExportJobRequest>;
+    readonly removeRequest: _angular_core.OutputEmitterRef<ImportExportRemoveRequest>;
+    /** Asked before a download. With an `href` the link navigates unless cancelled; without one the consumer produces the file. */
+    readonly downloadRequest: _angular_core.OutputEmitterRef<ImportExportDownloadRequest>;
+    /** Asked before the title's link navigates to the job's page; cancellable. */
+    readonly openRequest: _angular_core.OutputEmitterRef<ImportExportJobRequest>;
+    readonly loadMoreRequest: _angular_core.OutputEmitterRef<ImportExportRequest<ImportExportPressReason>>;
+    readonly reloadRequest: _angular_core.OutputEmitterRef<ImportExportRequest<ImportExportPressReason>>;
+    private readonly defaults;
+    private readonly native;
+    private readonly writtenLabel;
+    private readonly writtenLabelledBy;
+    private readonly listElement;
+    protected readonly jobActionsTemplate: _angular_core.Signal<SlImportExportJobActions | undefined>;
+    readonly id: string;
+    readonly titleId: string;
+    readonly listId: string;
+    protected readonly waitingRows: number[];
+    protected readonly pressReason: typeof pressReason;
+    readonly sizeValue: _angular_core.Signal<ImportExportCenterSize>;
+    readonly levelValue: _angular_core.Signal<ImportExportCenterLevel>;
+    readonly growingValue: _angular_core.Signal<ImportExportCenterGrowing>;
+    readonly timeFormatValue: _angular_core.Signal<ImportExportCenterTimeFormat>;
+    private readonly contextLocale;
+    readonly localeValue: _angular_core.Signal<string>;
+    readonly timeZoneValue: _angular_core.Signal<string | undefined>;
+    /** The family's words in the language in force, with this centre's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ImportExportCenterMessages>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    readonly viewList: _angular_core.Signal<readonly ImportExportView[]>;
+    /** The view: the model, then defaultView, then the first entry. */
+    readonly currentView: _angular_core.Signal<string>;
+    /** The shown keys: the model, then defaultExpanded. */
+    readonly currentExpanded: _angular_core.Signal<readonly string[]>;
+    readonly visibleJobs: _angular_core.Signal<readonly ImportExportJob[]>;
+    readonly active: _angular_core.Signal<number>;
+    readonly finished: _angular_core.Signal<ImportExportJob[]>;
+    readonly waiting: _angular_core.Signal<boolean>;
+    readonly showEmpty: _angular_core.Signal<boolean>;
+    readonly emptyTitle: _angular_core.Signal<string>;
+    private readonly remaining;
+    private readonly samples;
+    readonly jobViews: _angular_core.Signal<readonly JobView[]>;
+    private memory;
+    private revealing;
+    private previous;
+    constructor();
+    /** Focuses the first job's first control, or the list when there is none. */
+    focus(): void;
+    /** Shows a job's details, scrolls it into view and focuses its title: where a toast's View takes the reader. */
+    reveal(key: string): void;
+    protected formatCount(value: number): string;
+    private deadline;
+    private viewOf;
+    private messageOf;
+    protected forwardView(request: ChangeRequest<string | undefined>): void;
+    private selectView;
+    private requestExpanded;
+    protected toggle(key: string, reason: ImportExportPressReason, event: Event): void;
+    protected press(part: string, key: string, event: Event): void;
+    protected removeOne(key: string, event: Event): void;
+    protected clear(event: Event): void;
+    protected askDownload(key: string, file: JobFileRole, event: Event): void;
+    protected open(key: string, event: Event): void;
+    protected loadMore(event: Event): void;
+    protected reload(event: Event): void;
+    protected rememberFocus(event: FocusEvent): void;
+    private focusPart;
+    private restoreFocus;
+    private finishReveal;
+    /** The element the family renders on: the region a consumer's ref reaches. */
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlImportExportCenter, "section[slImportExportCenter]", ["slImportExportCenter"], { "jobs": { "alias": "jobs"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "growing": { "alias": "growing"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "now": { "alias": "now"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "defaultView": { "alias": "defaultView"; "required": false; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "view": "viewChange"; "expanded": "expandedChange"; "viewRequest": "viewRequest"; "expandedRequest": "expandedRequest"; "cancelRequest": "cancelRequest"; "retryRequest": "retryRequest"; "removeRequest": "removeRequest"; "downloadRequest": "downloadRequest"; "openRequest": "openRequest"; "loadMoreRequest": "loadMoreRequest"; "reloadRequest": "reloadRequest"; }, ["jobActionsTemplate"], ["[slImportExportCenterActions]", "[slImportExportCenterEmpty]", "[slImportExportCenterFooter]"], true, never>;
+}
+
+/**
+ * The family's one icon control, named by a tooltip with the words its
+ * accessible name carries: a cross with no words beside it is a control
+ * nobody can tell apart until it is named. The job's title describes it, and
+ * the tooltip's own content joins that description while it is open.
+ */
+declare class SlImportExportControl {
+    readonly text: _angular_core.InputSignal<string>;
+    /** The id of the element that says which job the control acts on. */
+    readonly describedBy: _angular_core.InputSignal<string | undefined>;
+    private readonly tooltip;
+    private readonly native;
+    constructor();
+    protected readonly describedByValue: _angular_core.Signal<string | null>;
+    protected onPointerEnter(event: PointerEvent): void;
+    protected onPointerLeave(event: PointerEvent): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerUp(): void;
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImportExportControl, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlImportExportControl, "button[slImportExportControl]", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "describedBy": { "alias": "describedBy"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.SlTooltip; inputs: {}; outputs: {}; }]>;
+}
+
+interface JobToastsOptions {
+    /**
+     * The toast's View control, written by the consumer and rendered per
+     * message. A function — a `viewChild` signal — is read when a toast is
+     * shown, so a template that exists only after the view is created still
+     * reaches it. The message's `data` carries `{ key }`, and `noticeKey(message.id)`
+     * from `@slotted/core/import-export-center` reads the same key back.
+     */
+    actions?: TemplateRef<{
+        $implicit: ToastMessage<ToastContent>;
+    }> | (() => TemplateRef<{
+        $implicit: ToastMessage<ToastContent>;
+    }> | undefined) | undefined;
+    /** Words laid over the catalog of the language in force: the announcement a toast carries. */
+    messages?: PartialMessages<ImportExportCenterMessages> | undefined;
+}
+/** What a notice's toast carries in `data`: the job it points at. */
+interface JobToastData {
+    readonly key: string;
+}
+/**
+ * A toast that points at a job, for a page that is not the centre: the job
+ * started, finished, finished with failed rows, failed. Called once in an
+ * injection context where the application keeps its jobs — the shell — so
+ * the reader hears of a job that finishes while they work elsewhere.
+ *
+ * The toast only points. It carries no progress, no cancel and no download;
+ * its one action is the consumer's View, which takes the reader to the centre
+ * and calls its `reveal(key)`. Its id is the job's key under
+ * `import-export-center:`, so the finishing notice replaces the starting one
+ * in place. Its announcement is the sentence the centre says for the same
+ * transition, which the shared announcer does not repeat when both are
+ * mounted. The jobs present the first time the signal is read made no move
+ * the reader saw, and get no toast.
+ */
+declare function jobToasts(jobs: Signal<readonly ImportExportJob[]>, { actions, messages }?: JobToastsOptions): void;
+
+export { IMPORT_EXPORT_CENTER_DEFAULTS, SlImportExportCenter, SlImportExportCenterActions, SlImportExportCenterEmpty, SlImportExportCenterFooter, SlImportExportCenterIdFactory, SlImportExportControl, SlImportExportJobActions, injectImportExportCenterDefaults, jobToasts, provideImportExportCenterDefaults };
+export type { ImportExportCenterDefaults, ImportExportCenterGrowing, ImportExportCenterLevel, ImportExportCenterSize, ImportExportCenterStatus, ImportExportCenterTimeFormat, ImportExportDownloadRequest, ImportExportJobContext, ImportExportJobRequest, ImportExportPressReason, ImportExportRemoveReason, ImportExportRemoveRequest, ImportExportRequest, ImportExportView, JobToastData, JobToastsOptions };
+//# sourceMappingURL=slotted-angular-import-export-center.d.ts.map

package/types/slotted-angular-import-export-center.d.ts.map

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

package/types/slotted-angular-inline-message.d.ts

@@ -0,0 +1,195 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+/** Which of the five semantic colours the message speaks in. */
+type InlineMessageTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/**
+ * The type step the message sits at. `sm` is the message of a field; `md` is
+ * the message of a section. Both read the control scales, which the theme
+ * restates per density.
+ */
+type InlineMessageSize = 'sm' | 'md';
+/**
+ * Which mark the message draws. `glyph` is the tone's own silhouette — the
+ * circled information, check, triangle and circled exclamation. `dot` is a
+ * neutral bullet in the tone's ink, the same shape for every tone including
+ * the help tone that draws no silhouette at all, so a column of messages under
+ * one field starts on one left edge. `none` draws nothing, and the tone is
+ * then said by the ink and by the weight of the sentence: it is what `field`
+ * and `field-group` ask for, because a silhouette repeated under every control
+ * of a form is texture rather than a warning (F2).
+ */
+type InlineMessageMark = 'glyph' | 'dot' | 'none';
+/**
+ * Whether the message announces itself, and how loudly. `off` is the default,
+ * because the WAI-ARIA APG records that a message already present when the page
+ * finishes loading is not announced whatever role it carries.
+ */
+type InlineMessageLive = 'off' | 'polite' | 'assertive';
+/**
+ * The word a reader hears before the message. `null` is a tone that is not a
+ * severity — help and information announce themselves by their sentence.
+ */
+type InlineMessagePrefixes = Record<InlineMessageTone, string | null>;
+/**
+ * The word a reader hears before the message, per tone.
+ *
+ * GOV.UK's Error message component publishes the idea and hard-codes the word;
+ * this table generalises it to every tone that is a severity and puts it behind
+ * the token below, which is the only translation surface this library has
+ * today. `accent` and `secondary` carry none: information and help announce
+ * themselves by their sentence, and a reader told “Information:” before every
+ * hint hears one more word per field for nothing.
+ */
+declare const INLINE_MESSAGE_PREFIXES: InlineMessagePrefixes;
+interface InlineMessageDefaults {
+    live: InlineMessageLive;
+    mark: InlineMessageMark;
+    prefixes: InlineMessagePrefixes;
+    size: InlineMessageSize;
+    tone: InlineMessageTone;
+}
+declare const INLINE_MESSAGE_DEFAULTS: InjectionToken<InlineMessageDefaults>;
+/**
+ * An application decides once what its messages are painted like and — the one
+ * that matters — what its severities are called, rather than repeating the same
+ * inputs on every field in a form. A message that states any of them itself
+ * still wins: an explicit input is never overridden by the token.
+ *
+ * `prefixes` is merged over the shipped table rather than replacing it, so a
+ * Portuguese application writes the three words it has and inherits the shape.
+ */
+declare function provideInlineMessageDefaults(defaults: Partial<Omit<InlineMessageDefaults, 'prefixes'>> & {
+    prefixes?: Partial<InlineMessagePrefixes>;
+}): {
+    provide: InjectionToken<InlineMessageDefaults>;
+    useFactory: () => InlineMessageDefaults;
+};
+/** What a message renders as here, before it states anything of its own. */
+declare function injectInlineMessageDefaults(): InlineMessageDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `tag` 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 SlInlineMessageIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlInlineMessageIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * One sentence about something else: a field, a section, an action. Help, an
+ * error, a warning, a confirmation, or a wait.
+ *
+ * The directive is written on the consumer's own element, and the element it
+ * belongs on is a `p`: the message is a sentence of prose about something else,
+ * and a paragraph is the box a screen reader reads as one unit.
+ *
+ * **The severity is a word as well as a colour.** A reader who cannot see the
+ * message hears the sentence and nothing else — neither the red ink nor the
+ * crossed circle reaches the accessibility tree — so the family writes the
+ * severity in clipped text before the message, which is GOV.UK's answer
+ * generalised to every tone and to a table an application replaces once.
+ *
+ * **The role goes on this element, not on an inner one.** `slAlert` puts its
+ * live role on the text part because it has a dismiss button beside the text,
+ * and MDN's `alert` role reference is explicit that the role is for text
+ * content alone. This family has no controls, so there is nothing to keep out.
+ */
+declare class SlInlineMessage {
+    /** Defaults to the token, then to `secondary` — help text. */
+    readonly tone: _angular_core.InputSignal<InlineMessageTone | undefined>;
+    /** Defaults to the token, then to `sm`. */
+    readonly size: _angular_core.InputSignal<InlineMessageSize | undefined>;
+    /** Defaults to the token, then to `off`. */
+    readonly live: _angular_core.InputSignal<InlineMessageLive | undefined>;
+    /**
+     * Which mark is drawn. Defaults to the token, then to `glyph`. `slField` and
+     * `slFieldGroup` ask for `none` instead, because a form reads a column of
+     * sentences rather than a column of silhouettes.
+     */
+    readonly mark: _angular_core.InputSignal<InlineMessageMark | undefined>;
+    /**
+     * The word read before the message. Unstated is the tone's own — `Error:`,
+     * `Warning:`, `Success:` — and the empty string removes it, for a message
+     * whose sentence already names the severity.
+     */
+    readonly prefix: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Removes the mark's box from the markup, for a message that carries its own
+     * artwork beside it. `mark='none'` is the other way to draw nothing: it is an
+     * axis a provider can set for every message under it, and it leaves the box
+     * in place for `reserve` to hold a line open with.
+     */
+    readonly hideIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The message is waiting for something: the mark becomes a turning ring. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Unstated rather than `false`, so a `field` can answer it once this family
+     * is inside one. Stated, it wins.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Holds one line box open whether or not there is a message, so the form
+     * below does not move when the error arrives.
+     */
+    readonly reserve: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly defaults;
+    /**
+     * An identifier bound by whatever renders the message. It is what a family
+     * that composes with this one — `field`, whose description and error *are*
+     * inline messages — uses to give the message an identifier derived from its
+     * own base, which a static attribute cannot express and a directive on the
+     * same element cannot write.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    private readonly writtenId;
+    private readonly generatedId;
+    /**
+     * The identifier an `aria-describedby` or an `aria-errormessage` points at.
+     * A consumer's own is never replaced, and the generated one is reachable from
+     * a template through `exportAs` — which is the reach an Angular template has
+     * and a React consumer answers with `useId` in their own component.
+     *
+     * A getter rather than a signal, so `message.messageId` keeps reading as a
+     * value in every template that already writes it. The host binding below
+     * calls it in a reactive context, so the `id` input above is tracked.
+     */
+    get messageId(): string;
+    /**
+     * A role the consumer wrote is never replaced by the family's. A host binding
+     * wins over a static attribute in Angular, so the written value has to be
+     * read before the binding is computed rather than after — the asymmetry with
+     * React, where a consumer's prop simply spreads over the family's.
+     */
+    private readonly writtenRole;
+    protected readonly resolvedTone: _angular_core.Signal<InlineMessageTone>;
+    protected readonly resolvedSize: _angular_core.Signal<InlineMessageSize>;
+    protected readonly resolvedLive: _angular_core.Signal<InlineMessageLive>;
+    protected readonly resolvedMark: _angular_core.Signal<InlineMessageMark>;
+    protected readonly glyph: _angular_core.Signal<"dot" | "check" | "minus" | "plus" | "x" | "ellipsis" | "copy" | "eye" | "eye-off" | "chevron-right" | "chevron-down" | "chevrons-right" | "panel-open" | "panel-close" | "arrow-left" | "pin" | "pin-off" | "external" | "calendar" | "clock" | "person" | "circle" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "stop" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "upload" | "file" | "trash" | "play" | "pause" | "rotate-ccw" | "file-image" | "file-text" | "file-spreadsheet" | "file-audio" | "file-video" | "file-archive" | "file-type" | "presentation" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check" | null>;
+    protected readonly role: _angular_core.Signal<string | null>;
+    protected readonly prefixWord: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlInlineMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlInlineMessage, "[slInlineMessage]", ["slInlineMessage"], { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "mark": { "alias": "mark"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "hideIcon": { "alias": "hideIcon"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "reserve": { "alias": "reserve"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["[slInlineMessageIcon]", "*"], true, never>;
+}
+
+/**
+ * A mark the page supplies instead of the tone's own. It is projected into the
+ * box the family draws, so it keeps the size, the colour and the place on the
+ * message's first line the tone's mark would have had.
+ *
+ * It is a marker rather than a component: what goes inside is the page's own
+ * artwork, and the family has nothing to add to it beyond where it sits.
+ */
+declare class SlInlineMessageIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlInlineMessageIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlInlineMessageIcon, "[slInlineMessageIcon]", ["slInlineMessageIcon"], {}, {}, never, never, true, never>;
+}
+
+export { INLINE_MESSAGE_DEFAULTS, INLINE_MESSAGE_PREFIXES, SlInlineMessage, SlInlineMessageIcon, SlInlineMessageIdFactory, injectInlineMessageDefaults, provideInlineMessageDefaults };
+export type { InlineMessageDefaults, InlineMessageLive, InlineMessageMark, InlineMessagePrefixes, InlineMessageSize, InlineMessageTone };
+//# sourceMappingURL=slotted-angular-inline-message.d.ts.map

package/types/slotted-angular-inline-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-inline-message.d.ts","sources":["../../inline-message/src/inline-message-defaults.ts","../../inline-message/src/inline-message.ts","../../inline-message/src/inline-message-parts.ts"],"mappings":";;;AAEA;AACM,KAAM,iBAAiB;AAE7B;;;;AAIG;KACS,iBAAiB;AAE7B;;;;;;;;;AASG;AACG,KAAM,iBAAiB;AAE7B;;;;AAIG;AACG,KAAM,iBAAiB;AAE7B;;;AAGG;AACG,KAAM,qBAAqB,GAAG,MAAM,CAAC,iBAAiB;AAE5D;;;;;;;;;AASG;AACH,cAAa,uBAAuB,EAAE,qBAMrC;UAEgB,qBAAqB;UAC9B,iBAAiB;UACjB,iBAAiB;cACb,qBAAqB;UACzB,iBAAiB;UACjB,iBAAiB;AACxB;AAUD,cAAa,uBAAuB,EAAA,cAAA,CAAA,qBAAA;AAKpC;;;;;;;;AAQG;AACH,iBAAgB,4BAA4B,WAChC,OAAO,CAAC,IAAI,CAAC,qBAAqB;AAC1C,eAAW,OAAO,CAAC,qBAAqB;AACzC;;sBAIiB,qBAAqB;AAQxC;AAED;AACA,iBAAgB,2BAA2B,IAAI,qBAAqB;AAIpE;;;;;AAKG;AACH,cACa,wBAAwB;;;oDAAxB,wBAAwB;;AAOpC;;ACrED;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAkCa,eAAe;;mBAEb,aAAA,CAAA,WAAA,CAAA,iBAAA;;mBAEA,aAAA,CAAA,WAAA,CAAA,iBAAA;;mBAEA,aAAA,CAAA,WAAA,CAAA,iBAAA;AACb;;;;AAIG;mBACU,aAAA,CAAA,WAAA,CAAA,iBAAA;AACb;;;;AAIG;qBACY,aAAA,CAAA,WAAA;AACf;;;;;AAKG;uBACc,aAAA,CAAA,wBAAA;;sBAED,aAAA,CAAA,wBAAA;AAChB;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AAGjB;;;AAGG;sBACa,aAAA,CAAA,wBAAA;AAEhB;AAEA;;;;;;AAMG;iBACQ,aAAA,CAAA,WAAA;AAEX;AACA;AAEA;;;;;;;;;AASG;;AAKH;;;;;AAKG;AACH;AAEA,qCAA+B,aAAA,CAAA,MAAA,CAAA,iBAAA;AAC/B,qCAA+B,aAAA,CAAA,MAAA,CAAA,iBAAA;AAC/B,qCAA+B,aAAA,CAAA,MAAA,CAAA,iBAAA;AAC/B,qCAA+B,aAAA,CAAA,MAAA,CAAA,iBAAA;AAG/B,8BAAwB,aAAA,CAAA,MAAA;AAKxB,6BAAuB,aAAA,CAAA,MAAA;AAGvB,mCAA6B,aAAA,CAAA,MAAA;oDA3FlB,eAAe;sDAAf,eAAe;AA8F3B;;ACrMD;;;;;;;AAOG;AACH,cAKa,mBAAmB;oDAAnB,mBAAmB;sDAAnB,mBAAmB;AAAG;;","names":[]}

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

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * A step on the space scale. Separation is chosen from the scale rather than
+ * stated as a length, so a theme retunes every layout at once and no component
+ * invents a rhythm of its own. `0` is the absence of separation.
+ */
+type InlineGap = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/** Across the flow, which for a run is the block axis. */
+type InlineAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+/** Along the flow, which for a run is the inline axis. */
+type InlineJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+type InlineWrap = 'wrap' | 'nowrap';
+/**
+ * Inline arranges its children along the inline axis and lets them wrap. It
+ * paints nothing and adds no semantics: the element is the one the consumer
+ * wrote, so a list of tags stays a list.
+ *
+ * An axis reaches the stylesheet only when someone decided it. The base rule
+ * already carries the family defaults — wrapping, centred, separated by half a
+ * rem — and a layout is the most numerous element in a document.
+ *
+ * There is no input that reverses the children. The order they are written in
+ * is the order they are read in, by a screen reader and by the Tab key alike.
+ */
+declare class SlInline {
+    /** Positions items across the flow. `baseline` puts their type on one line. */
+    readonly align: _angular_core.InputSignal<InlineAlign | undefined>;
+    /** Separation between items, as a step on the space scale. */
+    readonly gap: _angular_core.InputSignal<InlineGap | undefined>;
+    /** Positions items along the flow, and distributes the space between them. */
+    readonly justify: _angular_core.InputSignal<InlineJustify | undefined>;
+    /** `nowrap` keeps one line, and overflows a container narrower than it. */
+    readonly wrap: _angular_core.InputSignal<InlineWrap | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlInline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlInline, "[slInline]", ["slInline"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SlInline };
+export type { InlineAlign, InlineGap, InlineJustify, InlineWrap };
+//# sourceMappingURL=slotted-angular-inline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-inline.d.ts","sources":["../../inline/src/inline.ts"],"mappings":";;AAEA;;;;AAIG;AACG,KAAM,SAAS;AAErB;AACM,KAAM,WAAW;AAEvB;AACM,KAAM,aAAa;KAEb,UAAU;AAEtB;;;;;;;;;;;AAWG;AACH,cAoBa,QAAQ;;oBAEL,aAAA,CAAA,WAAA,CAAA,WAAA;;kBAEF,aAAA,CAAA,WAAA,CAAA,SAAA;;sBAEI,aAAA,CAAA,WAAA,CAAA,aAAA;;mBAEH,aAAA,CAAA,WAAA,CAAA,UAAA;oDARF,QAAQ;sDAAR,QAAQ;AASpB;;","names":[]}