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

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

@@ -0,0 +1,151 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { MessageScrollerPosition, MessageScrollerEdges, MessageScrollerState, ScrollToMessageOptions, ScrollCommandOptions } from '@slotted/core/message-scroller';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, MessageScrollerMessages } from '@slotted/core/i18n';
+
+interface MessageScrollerDefaults {
+    follow: boolean;
+    defaultPosition: MessageScrollerPosition;
+    peek: number;
+    scrollMargin: number;
+}
+declare const MESSAGE_SCROLLER_DEFAULTS: InjectionToken<MessageScrollerDefaults>;
+/**
+ * An application decides once whether its conversations follow a reply,
+ * where a saved one opens, and how much of the previous turn stays in view.
+ * A scroller that states any of them wins. Its words come from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideMessageScrollerDefaults(defaults: Partial<MessageScrollerDefaults>): {
+    provide: InjectionToken<MessageScrollerDefaults>;
+    useFactory: () => MessageScrollerDefaults;
+};
+declare function injectMessageScrollerDefaults(): MessageScrollerDefaults;
+
+/**
+ * The region a conversation scrolls in, on the `div` the page wrote. It fills
+ * a parent whose height is bounded; the viewport inside it scrolls and the
+ * jump control stands over it.
+ *
+ * The behaviour is `@slotted/core/message-scroller`: where a saved
+ * conversation opens, whether new words pull the view (`follow`), where a
+ * turn the reader sends stands (`anchor` on the item), older rows arriving
+ * above without moving the reader, and jumps — `scrollToMessage()` on the
+ * instance (`#chat="slMessageScroller"`). The engine writes the scroll state
+ * on the DOM itself; the instance's `state` signal is what the jump control
+ * reads.
+ */
+declare class SlMessageScroller {
+    readonly follow: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly defaultPosition: _angular_core.InputSignal<MessageScrollerPosition | undefined>;
+    readonly edgeThreshold: _angular_core.InputSignal<number | undefined>;
+    readonly scrollMargin: _angular_core.InputSignal<number | undefined>;
+    readonly peek: _angular_core.InputSignal<number | undefined>;
+    readonly preserveOnPrepend: _angular_core.InputSignal<boolean | undefined>;
+    /** A reply is streaming: the log is `aria-busy` and the change is announced once each way. */
+    readonly busy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * region's name, the jump controls, the unread line, the loader and the
+     * two announcements of a streaming reply.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<MessageScrollerMessages> | undefined>;
+    /** The reader reached the top — the moment to ask for older messages. */
+    readonly reachStart: _angular_core.OutputEmitterRef<"scroll">;
+    readonly anchorChange: _angular_core.OutputEmitterRef<{
+        id: string | null;
+        reason: "scroll" | "programmatic";
+    }>;
+    readonly scrollableChange: _angular_core.OutputEmitterRef<MessageScrollerEdges>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this scroller's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<MessageScrollerMessages>;
+    readonly resolvedPosition: _angular_core.Signal<MessageScrollerPosition>;
+    private readonly engine;
+    /** The engine's state: which edges the viewport can scroll toward, the count of rows out of view. */
+    readonly state: _angular_core.WritableSignal<MessageScrollerState>;
+    private readonly root;
+    private viewport;
+    private content;
+    private disconnect;
+    constructor();
+    /** @internal */ registerViewport(node: HTMLElement): void;
+    /** @internal */ registerContent(node: HTMLElement): void;
+    private connect;
+    scrollToMessage(id: string, options?: ScrollToMessageOptions): boolean;
+    scrollToEnd(options?: ScrollCommandOptions): boolean;
+    scrollToStart(options?: ScrollCommandOptions): boolean;
+    /** Moves focus to the viewport, which scrolls from the keyboard. */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScroller, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMessageScroller, "[slMessageScroller]", ["slMessageScroller"], { "follow": { "alias": "follow"; "required": false; "isSignal": true; }; "defaultPosition": { "alias": "defaultPosition"; "required": false; "isSignal": true; }; "edgeThreshold": { "alias": "edgeThreshold"; "required": false; "isSignal": true; }; "scrollMargin": { "alias": "scrollMargin"; "required": false; "isSignal": true; }; "peek": { "alias": "peek"; "required": false; "isSignal": true; }; "preserveOnPrepend": { "alias": "preserveOnPrepend"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "reachStart": "reachStart"; "anchorChange": "anchorChange"; "scrollableChange": "scrollableChange"; }, never, ["*"], true, never>;
+}
+/**
+ * The element that scrolls: a labelled region that takes focus, so the
+ * keyboard scrolls it; hidden, laid out, until the opening position applies.
+ */
+declare class SlMessageScrollerViewport {
+    private readonly owner;
+    protected readonly tabindex: string;
+    private readonly written;
+    protected readonly label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMessageScrollerViewport, "[slMessageScrollerViewport]", never, {}, {}, never, never, true, never>;
+}
+/** The rows: a WAI-ARIA `log`; `busy` on the scroller holds arrivals back until a reply is whole. */
+declare class SlMessageScrollerContent {
+    protected readonly owner: SlMessageScroller;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMessageScrollerContent, "[slMessageScrollerContent]", never, {}, {}, never, never, true, never>;
+}
+/** One row — a message, a separator, a line the system writes. */
+declare class SlMessageScrollerItem {
+    readonly messageId: _angular_core.InputSignal<string | undefined>;
+    readonly anchor: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMessageScrollerItem, "[slMessageScrollerItem]", never, { "messageId": { "alias": "messageId"; "required": false; "isSignal": true; }; "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** A day, or a line the system writes; `sticky` keeps it at the top while its rows are in view. */
+declare class SlMessageScrollerSeparator {
+    readonly sticky: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMessageScrollerSeparator, "[slMessageScrollerSeparator]", never, { "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** The line above the first message the reader has not seen. */
+declare class SlMessageScrollerUnread {
+    protected readonly owner: SlMessageScroller;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerUnread, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMessageScrollerUnread, "[slMessageScrollerUnread]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Older rows on their way: the shared ring and a line of text, read once as a status. */
+declare class SlMessageScrollerLoader {
+    protected readonly owner: SlMessageScroller;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerLoader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMessageScrollerLoader, "[slMessageScrollerLoader]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The control that takes the reader to the latest row — or, with
+ * `direction="start"`, to the first — on the `button` the page wrote. With
+ * nowhere to go it is inert and out of the tab order; when rows arrived out
+ * of view it says how many, in its name and on its face.
+ */
+declare class SlMessageScrollerJump {
+    readonly direction: _angular_core.InputSignal<"start" | "end">;
+    readonly behavior: _angular_core.InputSignal<ScrollBehavior>;
+    private readonly owner;
+    private readonly ownLabel;
+    protected readonly active: _angular_core.Signal<boolean>;
+    private readonly count;
+    protected readonly words: _angular_core.Signal<string | null>;
+    protected readonly label: _angular_core.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMessageScrollerJump, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMessageScrollerJump, "button[slMessageScrollerJump]", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { MESSAGE_SCROLLER_DEFAULTS, SlMessageScroller, SlMessageScrollerContent, SlMessageScrollerItem, SlMessageScrollerJump, SlMessageScrollerLoader, SlMessageScrollerSeparator, SlMessageScrollerUnread, SlMessageScrollerViewport, injectMessageScrollerDefaults, provideMessageScrollerDefaults };
+export type { MessageScrollerDefaults };
+//# sourceMappingURL=slotted-angular-message-scroller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-message-scroller.d.ts","sources":["../../message-scroller/src/message-scroller-defaults.ts","../../message-scroller/src/message-scroller.ts"],"mappings":";;;;;;UAGiB,uBAAuB;;qBAErB,uBAAuB;;;AAGzC;AASD,cAAa,yBAAyB,EAAA,cAAA,CAAA,uBAAA;AAKtC;;;;;AAKG;AACH,iBAAgB,8BAA8B,WAAW,OAAO,CAAC,uBAAuB;;sBAGpE,uBAAuB;AAO1C;AAED,iBAAgB,6BAA6B,IAAI,uBAAuB;;ACHxE;;;;;;;;;;;;AAYG;AACH,cAUa,iBAAiB;qBACb,aAAA,CAAA,wBAAA;8BAGS,aAAA,CAAA,WAAA,CAAA,uBAAA;4BACF,aAAA,CAAA,WAAA;2BACD,aAAA,CAAA,WAAA;mBACR,aAAA,CAAA,WAAA;gCACa,aAAA,CAAA,WAAA;;mBAEb,aAAA,CAAA,wBAAA;AACb;;;;AAIG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,uBAAA;;yBAGE,aAAA,CAAA,gBAAA;AACnB,2BAAqB,aAAA,CAAA,gBAAA;AAAgB;AAAuB;AAA+B;+BAClE,aAAA,CAAA,gBAAA,CAAA,oBAAA;AAEzB;;gBAEU,kBAAA,CAAA,gBAAA,CAAA,uBAAA;+BACe,aAAA,CAAA,MAAA,CAAA,uBAAA;AAIzB;;oBAQc,aAAA,CAAA,cAAA,CAAA,oBAAA;AAEd;;;;;AAgCA,4CAAwC,WAAW;AAKnD,2CAAuC,WAAW;AAKlD;0CAWsC,sBAAsB;AAI5D,0BAAsB,oBAAoB;AAI1C,4BAAwB,oBAAoB;;;oDArGjC,iBAAiB;sDAAjB,iBAAiB;AA6G7B;AASD;;;AAGG;AACH,cAUa,yBAAyB;AACpC;AACA;AAEA;AACA,8BAAwB,aAAA,CAAA,MAAA;;oDALb,yBAAyB;sDAAzB,yBAAyB;AAYrC;AAED;AACA,cAUa,wBAAwB;AACnC,8BAAwB,iBAAA;;oDADb,wBAAwB;sDAAxB,wBAAwB;AAOpC;AAED;AACA,cASa,qBAAqB;wBACd,aAAA,CAAA,WAAA;qBACH,aAAA,CAAA,wBAAA;oDAFJ,qBAAqB;sDAArB,qBAAqB;AAGjC;AAED;AACA,cAQa,0BAA0B;qBACtB,aAAA,CAAA,wBAAA;oDADJ,0BAA0B;sDAA1B,0BAA0B;AAEtC;AAED;AACA,cAUa,uBAAuB;AAClC,8BAAwB,iBAAA;oDADb,uBAAuB;sDAAvB,uBAAuB;AAEnC;AAED;AACA,cAWa,uBAAuB;AAClC,8BAAwB,iBAAA;oDADb,uBAAuB;sDAAvB,uBAAuB;AAEnC;AAED;;;;;AAKG;AACH,cAqBa,qBAAqB;wBACd,aAAA,CAAA,WAAA;uBACD,aAAA,CAAA,WAAA,CAAA,cAAA;AAEjB;AACA;AAEA,+BAAyB,aAAA,CAAA,MAAA;AAIzB;AAGA,8BAAwB,aAAA,CAAA,MAAA;AAIxB,8BAAwB,aAAA,CAAA,MAAA;AAOxB,6BAAyB,UAAU;oDAzBxB,qBAAqB;sDAArB,qBAAqB;AA8BjC;;","names":[]}

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

@@ -0,0 +1,348 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeReason, ChangeRequest } from '@slotted/core/state';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, MessageMessages, FamilyTranslator } from '@slotted/core/i18n';
+import * as _slotted_core_text_stream from '@slotted/core/text-stream';
+
+type MessageAlign = 'start' | 'end';
+type MessageLayout = 'bubble' | 'thread';
+type MessageActionsVisibility = 'always' | 'hover';
+type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed' | 'streaming';
+type BubbleVariant = 'solid' | 'soft' | 'outline' | 'plain';
+type BubbleTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+type MessageActivityStepStatus = 'complete' | 'current' | 'pending';
+/** Why a version, a reaction or a clamp moved. */
+type MessageChangeReason = Extract<ChangeReason, 'pointer' | 'keyboard'>;
+/** A request to send a message again. It carries no value. */
+interface MessageRetryRequest {
+    readonly reason: MessageChangeReason;
+    readonly source: Event;
+}
+interface MessageDefaults {
+    layout: MessageLayout;
+    actionsVisibility: MessageActionsVisibility;
+    variant: BubbleVariant;
+    tone: BubbleTone;
+}
+declare const MESSAGE_DEFAULTS: InjectionToken<MessageDefaults>;
+/**
+ * An application decides once how its messages are laid out, when their
+ * actions show, and what a bubble paints when nothing infers it. A group, a
+ * row or a bubble that states any of them still wins. Its words come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideMessageDefaults(defaults: Partial<MessageDefaults>): {
+    provide: InjectionToken<MessageDefaults>;
+    useFactory: () => MessageDefaults;
+};
+declare function injectMessageDefaults(): MessageDefaults;
+
+/**
+ * A run of messages from one sender on the `div` the page wrote. The rows
+ * inside it stand two pixels apart, the corners that face each other on the
+ * sender's side are drawn in, and a row with no avatar still stands on the
+ * column the run's avatar holds — read from the DOM by the stylesheet.
+ */
+declare class SlMessageGroup {
+    /** The layout every row in the run takes unless it states its own. */
+    readonly layout: i0.InputSignal<MessageLayout | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageGroup, "[slMessageGroup]", ["slMessageGroup"], { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One message of a conversation, on the `article` the page wrote, named by
+ * its author.
+ *
+ * **The side is asked once, here.** A bubble inside the row follows `align`
+ * and, when it states no painting, takes the reader's own for `end` — the
+ * accent's fill — and none for a thread.
+ *
+ * **The status is a fact about delivery.** `sending` and `streaming` are
+ * `aria-busy` and `data-loading`, `failed` is `data-invalid`, `read` is
+ * `data-read`.
+ *
+ * **Versions.** With `versionCount` of two or more, `slMessageVersions`
+ * pages between them; `[(version)]` is two-way and every move is asked
+ * first through `versionChangeRequest`.
+ */
+declare class SlMessage {
+    /** The sender's side. `end` is the reader's own message. */
+    readonly align: i0.InputSignal<MessageAlign>;
+    /** Bubbles in a conversation, or rows of a comment thread. Falls back to the group, then the token. */
+    readonly layout: i0.InputSignal<MessageLayout | undefined>;
+    readonly actionsVisibility: i0.InputSignal<MessageActionsVisibility | undefined>;
+    readonly status: i0.InputSignal<MessageStatus | undefined>;
+    /** The version on screen, from 0. Two-way; every move is asked first. */
+    readonly version: i0.ModelSignal<number>;
+    /** How many versions exist; the pager draws when there are two or more. */
+    readonly versionCount: i0.InputSignal<number>;
+    /**
+     * Words laid over the catalog of the language in force, key by key, for
+     * this row and every part and bubble inside it.
+     */
+    readonly messages: i0.InputSignal<PartialMessages<MessageMessages> | undefined>;
+    /** Emitted before the version moves; `cancel()` keeps it. */
+    readonly versionChangeRequest: i0.OutputEmitterRef<ChangeRequest<number>>;
+    /** Asks to send the message again; `slBubbleRetry` emits it. */
+    readonly retry: i0.OutputEmitterRef<MessageRetryRequest>;
+    private readonly defaults;
+    private readonly group;
+    private readonly ownLabel;
+    readonly authorId: string;
+    /** The family's words in the language in force, with this row's `messages` laid over them. */
+    readonly t: FamilyTranslator<MessageMessages>;
+    private readonly authorPresent;
+    readonly resolvedLayout: i0.Signal<MessageLayout>;
+    readonly resolvedActions: i0.Signal<MessageActionsVisibility>;
+    readonly busy: i0.Signal<boolean>;
+    /** The author names the article unless the page named it: `aria-labelledby` would outrank its `aria-label`. */
+    protected readonly labelledBy: i0.Signal<string | null>;
+    registerAuthor(present: boolean): void;
+    requestVersion(next: number, reason: MessageChangeReason, source: Event): void;
+    requestRetry(reason: MessageChangeReason, source: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlMessage, "[slMessage]", ["slMessage"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "actionsVisibility": { "alias": "actionsVisibility"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "versionCount": { "alias": "versionCount"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "version": "versionChange"; "versionChangeRequest": "versionChangeRequest"; "retry": "retry"; }, never, ["*"], true, never>;
+}
+
+/** The box the sender's avatar stands in: at the foot of a run, or beside the name in a thread. */
+declare class SlMessageAvatar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageAvatar, "[slMessageAvatar]", never, {}, {}, never, never, true, never>;
+}
+/** The column of the words: the header, the bubbles, the attachments and the footer. */
+declare class SlMessageBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageBody, "[slMessageBody]", never, {}, {}, never, never, true, never>;
+}
+/** The name and, in a thread, the hour, over the words. */
+declare class SlMessageHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageHeader, "[slMessageHeader]", never, {}, {}, never, never, true, never>;
+}
+/** What is said about the message under it: a receipt outside a bubble, the actions, the versions. */
+declare class SlMessageFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageFooter, "[slMessageFooter]", never, {}, {}, never, never, true, never>;
+}
+/** The hour, on the `time` element the page wrote with its `datetime`. */
+declare class SlMessageTime {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageTime, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageTime, "time[slMessageTime]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The sender's name. While it is on the page the article is named by it, so a
+ * screen reader that moves from article to article hears who spoke. A page
+ * `id` is kept.
+ */
+declare class SlMessageAuthor {
+    private readonly owner;
+    protected readonly id: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageAuthor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageAuthor, "[slMessageAuthor]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The hour and the delivery mark inside a bubble, riding at the end of the
+ * last line. A receipt inside it draws its mark and keeps its word for
+ * assistive technology.
+ */
+declare class SlBubbleMeta {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleMeta, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlBubbleMeta, "[slBubbleMeta]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Where the message is in its delivery. Inside `slBubbleMeta` it is a mark
+ * beside the hour with the word hidden for assistive technology; anywhere
+ * else it is the word alone — a mark beside a word of twelve pixels is two
+ * voices saying one thing.
+ */
+declare class SlMessageReceipt {
+    /** Falls back to the row's status. */
+    readonly status: i0.InputSignal<"sending" | "sent" | "delivered" | "read" | "failed" | undefined>;
+    private readonly owner;
+    private readonly inMeta;
+    readonly resolved: i0.Signal<"sending" | "sent" | "delivered" | "read" | "failed">;
+    protected readonly word: i0.Signal<string>;
+    protected readonly glyph: i0.Signal<"clock" | "check" | "check-check" | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageReceipt, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlMessageReceipt, "[slMessageReceipt]", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The message's own actions — copy, reply, rate — as a toolbar the row reveals. */
+declare class SlMessageActions {
+    private readonly owner;
+    private readonly written;
+    protected readonly label: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageActions, "[slMessageActions]", never, {}, {}, never, never, true, never>;
+}
+/** What a reply is doing before it has words, as a short log of steps; a status region. */
+declare class SlMessageActivity {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageActivity, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlMessageActivity, "[slMessageActivity]", never, {}, {}, never, never, true, never>;
+}
+/** One step of an activity: done, in progress, or waiting. */
+declare class SlMessageActivityStep {
+    readonly status: i0.InputSignal<MessageActivityStepStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageActivityStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlMessageActivityStep, "[slMessageActivityStep]", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * `2 de 3` between two controls that page through a reply's versions. It
+ * draws its controls only while there are two or more; they stop at the ends
+ * rather than wrapping. `ArrowLeft` and `ArrowRight` page as well, mirrored in
+ * a right-to-left document.
+ */
+declare class SlMessageVersions {
+    protected readonly owner: SlMessage;
+    private readonly host;
+    protected readonly label: i0.Signal<string>;
+    protected step(delta: number, event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlMessageVersions, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlMessageVersions, "[slMessageVersions]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The surface a message's words are painted on, on the `div` the page wrote.
+ *
+ * **Painting.** `variant` × `tone`. A bubble that states neither takes it from
+ * its row — the reader's own message is the accent's fill, a thread paints no
+ * box — then from the token; the result is written as `data-variant` and
+ * `data-tone`.
+ *
+ * **Clamp.** With `maxLines`, a longer text shows its first lines and a
+ * “show more” control under the surface, drawn only while the text
+ * overflows; the whole text stays in the DOM. `[(revealed)]` is two-way and
+ * every move is asked first through `revealedChangeRequest`.
+ */
+declare class SlBubble {
+    readonly variant: i0.InputSignal<BubbleVariant | undefined>;
+    readonly tone: i0.InputSignal<BubbleTone | undefined>;
+    /** Lines shown before the text is clamped behind a “show more” control. */
+    readonly maxLines: i0.InputSignal<number | undefined>;
+    /** The text shown whole. Two-way; every move is asked first. */
+    readonly revealed: i0.ModelSignal<boolean>;
+    readonly revealedChangeRequest: i0.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly defaults;
+    private readonly row;
+    readonly contentId: string;
+    /** The family's words: the row's, or the language in force outside a row. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<_slotted_core_i18n.MessageMessages>;
+    readonly overflowing: i0.WritableSignal<boolean>;
+    readonly clamped: i0.Signal<boolean>;
+    readonly resolvedVariant: i0.Signal<BubbleVariant>;
+    readonly resolvedTone: i0.Signal<BubbleTone>;
+    protected toggle(event: MouseEvent): void;
+    requestRevealed(next: boolean, reason: MessageChangeReason, source: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubble, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubble, "[slBubble]", ["slBubble"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; }, { "revealed": "revealedChange"; "revealedChangeRequest": "revealedChangeRequest"; }, never, ["*"], true, never>;
+}
+/**
+ * The painted surface, on the `div`, `button` or `a` the page wrote: a quick
+ * reply is a `button`, a way out of the thread an `a`, and each keeps the
+ * painting, the hover, the press and the focus ring. Inside a clamped bubble
+ * it measures whether its text overflows, which is what draws “show more”.
+ */
+declare class SlBubbleContent {
+    private readonly bubble;
+    protected readonly id: string | null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlBubbleContent, "[slBubbleContent]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The message a reply answers, at the head of the surface, on the `div` or
+ * `button` the page wrote. On a `button` it asks the page to scroll to the
+ * quoted message through `(click)` — the scroller's `scrollToMessage`.
+ */
+declare class SlBubbleQuote {
+    readonly author: i0.InputSignal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleQuote, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubbleQuote, "[slBubbleQuote]", never, { "author": { "alias": "author"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The words of a streamed reply, entering as they arrive, on the `span` the
+ * page wrote.
+ *
+ * `text` is everything received so far. What extends the previous text is
+ * split into words by `@slotted/core/text-stream`; each word is in the DOM at
+ * once and enters as a `stream-chunk` after a delay of at most 320 ms, so a
+ * burst from the transport reads as a wave rather than a block. A chunk that
+ * has entered is folded back into plain text. Text that does not extend the
+ * previous — a regenerated reply — replaces it at once, and so does every
+ * arrival under reduced motion.
+ *
+ * Arrivals animate while the row is `streaming`, and the arrival that ends
+ * the stream with it; `animate` states it outright.
+ */
+declare class SlBubbleStream {
+    private readonly row;
+    private readonly view;
+    /** The whole reply received so far. Text that extends it enters word by word. */
+    readonly text: i0.InputSignal<string>;
+    /** Let arrivals enter. Falls back to whether the row is `streaming`. */
+    readonly animate: i0.InputSignal<boolean | undefined>;
+    private readonly streaming;
+    protected readonly stream: i0.WritableSignal<_slotted_core_text_stream.StreamState>;
+    private started;
+    private wasStreaming;
+    constructor();
+    protected settle(key: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleStream, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubbleStream, "span[slBubbleStream]", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "animate": { "alias": "animate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The caret at the end of the words that have arrived while a reply streams. */
+declare class SlBubbleCaret {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleCaret, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlBubbleCaret, "[slBubbleCaret]", never, {}, {}, never, never, true, never>;
+}
+/** Three dots in the bubble of someone writing, named for assistive technology. */
+declare class SlBubbleTyping {
+    private readonly t;
+    private readonly written;
+    /** A written `aria-label` wins over the `typing` message. */
+    protected readonly label: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleTyping, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubbleTyping, "[slBubbleTyping]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The round control beside a message that did not go, on the `button` the
+ * page wrote. It asks the row's `(retry)` with the reason, after the page's
+ * own `(click)`.
+ */
+declare class SlBubbleRetry {
+    private readonly row;
+    private readonly t;
+    private readonly written;
+    protected readonly label: i0.Signal<string>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleRetry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubbleRetry, "button[slBubbleRetry]", never, {}, {}, never, never, true, never>;
+}
+/** The row of reactions straddling the surface's lower edge; in a thread, a row under the words. */
+declare class SlBubbleReactions {
+    private readonly t;
+    private readonly written;
+    protected readonly label: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleReactions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlBubbleReactions, "[slBubbleReactions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * One reaction on the `button` the page wrote: the emoji or mark the page
+ * writes inside it, and its count. `[(pressed)]` is two-way and every move is
+ * asked first through `pressedChangeRequest`; the count is the page's store's.
+ */
+declare class SlBubbleReaction {
+    readonly pressed: i0.ModelSignal<boolean>;
+    readonly count: i0.InputSignal<number | undefined>;
+    readonly disabled: i0.InputSignal<boolean>;
+    readonly pressedChangeRequest: i0.OutputEmitterRef<ChangeRequest<boolean>>;
+    protected toggle(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlBubbleReaction, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlBubbleReaction, "button[slBubbleReaction]", never, { "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; "pressedChangeRequest": "pressedChangeRequest"; }, never, ["*"], true, never>;
+}
+
+export { MESSAGE_DEFAULTS, SlBubble, SlBubbleCaret, SlBubbleContent, SlBubbleMeta, SlBubbleQuote, SlBubbleReaction, SlBubbleReactions, SlBubbleRetry, SlBubbleStream, SlBubbleTyping, SlMessage, SlMessageActions, SlMessageActivity, SlMessageActivityStep, SlMessageAuthor, SlMessageAvatar, SlMessageBody, SlMessageFooter, SlMessageGroup, SlMessageHeader, SlMessageReceipt, SlMessageTime, SlMessageVersions, injectMessageDefaults, provideMessageDefaults };
+export type { BubbleTone, BubbleVariant, MessageActionsVisibility, MessageActivityStepStatus, MessageAlign, MessageChangeReason, MessageDefaults, MessageLayout, MessageRetryRequest, MessageStatus };
+//# sourceMappingURL=slotted-angular-message.d.ts.map

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

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