@h-k-dev/angular-email-editor 0.0.0-placeholder.0 → 0.0.1

package/types/h-k-dev-angular-email-editor-attachment-chip.d.ts

@@ -0,0 +1,271 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, OnInit } from '@angular/core';
+
+/**
+ * What a chip needs to draw an attachment: a name and, if they are known, a
+ * MIME type and a size. Deliberately structural rather than a class — a
+ * browser `File` already satisfies it, so a host that holds `File[]` binds it
+ * straight in with no adapter, and one that holds parsed MIME parts
+ * (postal-mime hands back a name, a `mimeType` and the content, not a
+ * `File`) maps three fields.
+ */
+interface Attachment {
+    readonly name: string;
+    /** MIME type, e.g. `application/pdf`. Only the icon reads it. */
+    readonly type?: string;
+    /** Size in bytes. Shown under the name, and what simulated progress
+        paces itself by. */
+    readonly size?: number;
+}
+/**
+ * Where an attachment's transfer is, in the stages uploaders agree on —
+ * Uppy, tus and their kin name them the same way. `preprocessing` is the
+ * work before the bytes move (a fingerprint, a virus scan) and has no
+ * number; `queued` is accepted and waiting for a connection, with nothing
+ * happening yet; `uploading` is the bytes moving, with a number;
+ * `postprocessing` is the work after (a transcode, a scan on the far side),
+ * again with none; `complete` is done. A chip draws a sweep for the stages
+ * where work runs without a number, a bar for the one with, and keeps
+ * quiet while a transfer only waits.
+ *
+ * The set is a vocabulary, not a sequence: which stages a pipeline has, and
+ * in what order, is the host's — a store that scans on the far side queues
+ * before it preprocesses, one that caps its connections queues after.
+ */
+type AttachmentStatus = 'preprocessing' | 'queued' | 'uploading' | 'postprocessing' | 'complete';
+/** The stages during which the transfer is not done — a waiting one
+    included, since the message is no more sendable for it. */
+declare function attachmentInFlight(status: AttachmentStatus | null | undefined): boolean;
+/** The families a chip draws a distinct icon for. */
+type AttachmentKind = 'image' | 'video' | 'audio' | 'pdf' | 'archive' | 'spreadsheet' | 'presentation' | 'document' | 'message' | 'file';
+/** The kind of file a MIME type stands for; `file` when the type is unknown
+    or matches nothing above. Case-insensitive — a type off the wire may be
+    shouted. */
+declare function attachmentKind(type: string | undefined): AttachmentKind;
+/**
+ * A byte count the way a mail client prints it: binary steps, one decimal
+ * below ten ("2.5 MB", "15 MB"), none for bytes. The number follows the
+ * locale ("2,5 MB" in German); the unit labels are the ones every mail
+ * client uses, not CLDR's ("kB", "byte").
+ */
+declare function formatAttachmentSize(bytes: number, locale?: string): string;
+
+/** What the host's `data-scanning` reads: `'true'` while the band sweeps,
+    `'leaving'` while it fades out, `null` when there is no band. */
+type ScanningState = 'true' | 'leaving' | null;
+
+/**
+ * The chip's template slots. A host that wants its own icon or its own
+ * progress readout hands the chip a template, and the chip renders it
+ * inside the box it already sizes — so a Material icon, a font icon or a
+ * custom SVG lands in the same 1em square the default glyph does, and the
+ * stylesheet never has to reach into the host's markup.
+ *
+ *     <li email-attachment-chip [attachment]="file">
+ *       <mat-icon *emailAttachmentIcon="let kind = kind" inline>
+ *         {{ kind === 'pdf' ? 'picture_as_pdf' : 'attach_file' }}
+ *       </mat-icon>
+ *     </li>
+ */
+/** What the icon template is given: the attachment, and the kind the chip
+    worked out from its MIME type. */
+interface AttachmentChipIconContext {
+    readonly $implicit: Attachment;
+    readonly kind: AttachmentKind;
+}
+/** Which progress the chip is drawing: a bar with a number, a sweep with
+    none, the chip's own fake fill, or nothing yet while the transfer waits. */
+type AttachmentProgressMode = 'determinate' | 'indeterminate' | 'simulated' | 'queued';
+/** What the progress template is given: the attachment and everything the
+    chip knows about its transfer. `percent` is `progress` as a whole number
+    of 0–100, clamped. */
+interface AttachmentChipProgressContext {
+    readonly $implicit: Attachment;
+    readonly status: AttachmentStatus | null;
+    readonly progress: number | null;
+    readonly percent: number;
+    readonly mode: AttachmentProgressMode;
+}
+/**
+ * The chip's icon slot: mark an `ng-template` with it (or use the `*`
+ * shorthand on the element itself) and the chip renders it in place of the
+ * default glyph, in the icon box. The box is `--email-attachment-chip-icon-size`
+ * square and sets `font-size` and `color` to match, so a `mat-icon` with
+ * `inline`, a font icon, or an SVG drawn at `1em` all fit without a rule.
+ */
+declare class AttachmentChipIcon {
+    readonly template: TemplateRef<AttachmentChipIconContext>;
+    static ngTemplateContextGuard(_directive: AttachmentChipIcon, context: unknown): context is AttachmentChipIconContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttachmentChipIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AttachmentChipIcon, "ng-template[emailAttachmentIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The chip's progress slot: the readout in the trailing square, rendered
+ * from the host's template instead of the default percentage. The bar along
+ * the chip's edge and the scanning sweep stay the chip's — this replaces
+ * only what the square shows.
+ */
+declare class AttachmentChipProgress {
+    readonly template: TemplateRef<AttachmentChipProgressContext>;
+    static ngTemplateContextGuard(_directive: AttachmentChipProgress, context: unknown): context is AttachmentChipProgressContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttachmentChipProgress, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AttachmentChipProgress, "ng-template[emailAttachmentProgress]", never, {}, {}, never, never, true, never>;
+}
+
+/** How simulated progress paces itself. */
+interface AttachmentChipOptions {
+    /** The connection a simulated transfer pretends to have, in bytes per
+        second. A fast line by default — the point is the gesture, not a wait. */
+    readonly bytesPerSecond: number;
+    /** Floor in ms, so a tiny file still shows a visible fill. */
+    readonly minDuration: number;
+    /** Ceiling in ms, so a large file never makes anyone wait on a fake. */
+    readonly maxDuration: number;
+    /** Duration in ms for an attachment whose size is unknown. */
+    readonly fallbackDuration: number;
+    /** How long the full bar stays before the chip settles, in ms — so 100%
+        is something the eye gets to see, not a frame on the way out. */
+    readonly linger: number;
+}
+/** Overrides for simulated progress, app-wide or per subtree:
+    `{ provide: ATTACHMENT_CHIP_OPTIONS, useValue: { bytesPerSecond: 2e6 } }`.
+    Anything left out keeps its default. */
+declare const ATTACHMENT_CHIP_OPTIONS: InjectionToken<Partial<AttachmentChipOptions>>;
+/** How long a simulated transfer of `size` bytes runs, in ms: size over the
+    assumed speed, clamped to the floor and ceiling. The linger after it is
+    not part of this — it is the same for every size. */
+declare function simulatedDuration(size: number | undefined, options?: Omit<AttachmentChipOptions, 'linger'>): number;
+/**
+ * One attachment, laid out like a list row with an avatar:
+ *
+ *     [icon] | name        | [progress / ×]
+ *            | size        |
+ *     ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+ *
+ * Progress is a bar along the bottom edge that fills with the number; with
+ * no number the whole chip is swept by a band of light instead, the way a
+ * scanner passes over a page — and when the number arrives mid-sweep the
+ * band fades out on its way rather than vanishing. The square at the end is
+ * shared: while work is in flight it holds the readout (the percentage,
+ * nothing while there is none), and the remove button paints over it on
+ * hover or focus, always on a touch screen. The chip owns all of that
+ * motion: the stylesheet draws it and `attachment-chip.animation.ts` times
+ * it; a host only says where the transfer is.
+ *
+ * **Stages are `status`.** A host with an upload pipeline binds the stage
+ * it is in — `preprocessing`, `queued`, `uploading`, `postprocessing`,
+ * `complete`, the vocabulary of Uppy and tus — and `progress` (0–1) while
+ * uploading. The stages where work runs without a number sweep, the one
+ * with a number fills, and `queued` keeps quiet: busy, no bar, no sweep,
+ * announced as waiting. The progress names itself after the stage
+ * ("Preparing report.pdf") unless `progressLabel` says otherwise. The stage
+ * is reflected as `data-status` on the host. Which stages a host has, and
+ * in what order, is the host's pipeline; the chip only draws the one it is
+ * given.
+ *
+ * **State is ARIA.** `aria-busy` is reflected while any stage is in flight,
+ * and is also an input for a host with no stages to tell: busy with a
+ * `progress` fills, busy with `null` sweeps. `aria-disabled` takes the
+ * remove button out of play. Both inputs go under their ARIA names, so a
+ * host writes `[aria-busy]="upload.pending"` exactly as it would on any
+ * element, and the chip reflects them back onto itself — they are the
+ * styling hooks too (`[email-attachment-chip][aria-busy='true']`).
+ *
+ * **`simulateProgress`** is for hosts that already have the bytes and only
+ * want the "attaching" moment: the chip runs a fill paced by `size` over
+ * `ATTACHMENT_CHIP_OPTIONS`, is busy while it runs and for a moment after
+ * the bar is full, and settles on its own.
+ * It plays once, when the chip is created; it is skipped for reduced motion
+ * and on the server; and a real `status` or `aria-busy` from the host always wins. It
+ * never emits and never gates anything — don't use it for work that is
+ * really happening but untracked; that is `aria-busy` with no `progress`.
+ * The fake announces no number to assistive tech, only that it is busy.
+ *
+ * **Parts are `data-slot`s.** Every part carries one — `icon`, `label`,
+ * `name`, `size`, `trailing`, `progress` (the readout, with
+ * `progress-value` inside), `progress-track`, `progress-indicator` (the
+ * bar), `remove` — and that is how it is styled from outside:
+ * `[email-attachment-chip] [data-slot='name'] { … }`. Theme it through the
+ * `--email-*` tokens; a structural override reaches a part with two
+ * attributes (`[email-attachment-chip] [data-slot='name'][data-slot]`).
+ *
+ * **Slots are templates.** `icon` and `progress` are boxes the chip sizes;
+ * a host fills either with its own template by marking an `ng-template`
+ * `emailAttachmentIcon` / `emailAttachmentProgress` (or the `*` shorthand on
+ * the element). The icon box is `--email-attachment-chip-icon-size` square
+ * and sets `font-size` and `color` to match, so a `mat-icon` with `inline`, a
+ * font icon or an SVG drawn at `1em` all fit with no rule of their own; the
+ * template gets the attachment and its `kind`. The progress template gets
+ * the attachment, `status`, `progress`, `percent` and `mode`, and replaces
+ * only the readout — the bar and the sweep stay the chip's.
+ *
+ * **It asks, it does not do.** The chip holds no list: `removed` is a
+ * request the host answers by dropping the item (and cancelling its upload).
+ * Picking, dropping, uploading and assembling the MIME are the host's.
+ *
+ * Opt-in enter/leave animations ship with it:
+ * `animate.enter="email-attachment-chip-enter"` and
+ * `animate.leave="email-attachment-chip-leave"` on the chip's element.
+ *
+ * Meant for an `<li>` inside `<ul email-attachment-chips>`. No Material, no
+ * icon font, no headless library.
+ */
+declare class AttachmentChip implements OnInit {
+    #private;
+    /** The file this chip stands for. A `File` satisfies it as it is. */
+    readonly attachment: _angular_core.InputSignal<Attachment>;
+    /** Set false for a read-only message (a sent copy, a preview): the chip
+        stays, the remove button goes. */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Prefix for the remove button's accessible name — "Remove report.pdf". */
+    readonly removeLabel: _angular_core.InputSignal<string>;
+    /** Which stage the transfer is in. `null` for a host with no stages to
+        tell — then `aria-busy` and `progress` alone describe the work. */
+    readonly status: _angular_core.InputSignal<AttachmentStatus | null>;
+    /** Work is in flight for this attachment (an upload, a download, a scan),
+        for a host that has no stages to tell. */
+    readonly ariaBusy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** How far the work is, 0–1, while uploading. `null` when there is no
+        number. */
+    readonly progress: _angular_core.InputSignal<number | null>;
+    /** The remove button is out of play — e.g. while the message sends. */
+    readonly ariaDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Run a fake transfer once, paced by the attachment's size. */
+    readonly simulateProgress: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Prefix for the progress's accessible name — "Uploading report.pdf".
+        Left out, it follows the stage: Preparing, Uploading, Processing. */
+    readonly progressLabel: _angular_core.InputSignal<string | undefined>;
+    /** The remove button was pressed. The host drops the attachment; the chip
+        goes when the host's list no longer has it. */
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    /** The host's own icon, if it handed one in. */
+    protected readonly iconTemplate: _angular_core.Signal<AttachmentChipIcon | undefined>;
+    /** The host's own progress readout, if it handed one in. */
+    protected readonly progressTemplate: _angular_core.Signal<AttachmentChipProgress | undefined>;
+    /** Busy for real (a stage in flight, or the host said so) or for show (a
+        simulation running). Public so the container can tell whether any of
+        its chips is. */
+    readonly busy: _angular_core.Signal<boolean>;
+    /** Which progress to draw, if any: a sweep for a stage with no number, a
+        bar for one with, nothing yet for one that waits, and the host's real
+        state beats a simulation. Reflected on the host as `data-mode`. */
+    protected readonly mode: _angular_core.Signal<AttachmentProgressMode | null>;
+    /** The scanning band's state on the host — `true` while there is no
+        number, `leaving` for a moment after one arrives. */
+    protected readonly scanning: _angular_core.Signal<ScanningState>;
+    /** What the progress is called: the host's word, or the stage's. */
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly percent: _angular_core.Signal<number>;
+    protected readonly kind: _angular_core.Signal<AttachmentKind>;
+    protected readonly icon: _angular_core.Signal<string>;
+    protected readonly iconContext: _angular_core.Signal<AttachmentChipIconContext>;
+    protected readonly progressContext: _angular_core.Signal<AttachmentChipProgressContext>;
+    protected readonly size: _angular_core.Signal<string>;
+    protected readonly duration: _angular_core.Signal<number>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttachmentChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AttachmentChip, "[email-attachment-chip]", never, { "attachment": { "alias": "attachment"; "required": true; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaBusy": { "alias": "aria-busy"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; "isSignal": true; }; "simulateProgress": { "alias": "simulateProgress"; "required": false; "isSignal": true; }; "progressLabel": { "alias": "progressLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, ["iconTemplate", "progressTemplate"], never, true, never>;
+}
+
+export { ATTACHMENT_CHIP_OPTIONS, AttachmentChip, AttachmentChipIcon, AttachmentChipProgress, attachmentInFlight, attachmentKind, formatAttachmentSize, simulatedDuration };
+export type { Attachment, AttachmentChipIconContext, AttachmentChipOptions, AttachmentChipProgressContext, AttachmentKind, AttachmentProgressMode, AttachmentStatus };

package/types/h-k-dev-angular-email-editor-attachment-chips.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+import { Attachment, AttachmentChip } from '@h-k-dev/angular-email-editor/attachment-chip';
+
+/**
+ * The row a message's attachment chips sit in — under the body, in Gmail's
+ * spot: the strip belongs to the message, not to the envelope.
+ *
+ * **The strip is the form's control.** It holds the list as its `value` —
+ * a `FormValueControl` over the attachments, bound with `[formField]` or
+ * two-way as `[(value)]` — and nothing else: the host renders one
+ * `<li email-attachment-chip>` per item into it and decides, chip by chip
+ * in its own template, what each one shows (real progress, a simulated one,
+ * none). That is why the pair is two components. The chips register by
+ * being content: each one's `removed` is relayed into the value for as long
+ * as it is in the strip, so a chip's × takes its item out of the message
+ * with no wiring on the host's side. Identity, not name — the host's items
+ * are the value's, so the chip that asked is exactly the item that goes.
+ * `disabled` (the form's, or the host's) holds the value still.
+ *
+ * `aria-busy` is reflected while any chip is busy, so a host can style or
+ * gate on the strip as a whole (`[email-attachment-chips][aria-busy='true']`,
+ * or a disabled Send).
+ *
+ * Meant for a `<ul>`. `role="list"` is set anyway, because `list-style: none`
+ * costs a list its semantics in Safari. Hidden while it holds no chips, so a
+ * host can place it unconditionally.
+ */
+declare class AttachmentChips<T extends Attachment = Attachment> implements FormValueControl<T[]> {
+    /** Names the list for assistive tech. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** The attachments the strip stands for — the form's value. The host
+        renders a chip per item; a chip's removal takes its item out of here. */
+    readonly value: _angular_core.ModelSignal<T[]>;
+    /** Nothing may leave the value — e.g. while the message sends. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly chips: _angular_core.Signal<readonly AttachmentChip[]>;
+    /** Any chip in the strip is busy — uploading, downloading, simulating. */
+    readonly busy: _angular_core.Signal<boolean>;
+    constructor();
+    /** Takes one attachment out of the value, by identity. A no-op while
+        disabled. */
+    remove(attachment: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttachmentChips<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AttachmentChips<any>, "[email-attachment-chips]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["chips"], ["*"], true, never>;
+}
+
+export { AttachmentChips };

package/types/h-k-dev-angular-email-editor-chat-input.d.ts

@@ -0,0 +1,101 @@
+import * as _angular_core from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+import { Node } from 'prosemirror-model';
+import { Editor } from '@h-k-dev/angular-email-editor';
+
+/** The text as it is sent: a line per block, a list item as a dash line —
+    the writer's points, kept as points. */
+declare function chatInputText(doc: Node): string;
+/**
+ * The behaviour of a chat input, on an element of the host's own: a field
+ * to ask an assistant with, the way a chat's message box works — Enter
+ * sends, Shift-Enter breaks the line — that also takes **lists**, so a list
+ * of points reaches the assistant as points: `- ` or `1. ` at a line's
+ * start begins one, Enter goes on to the next item, Enter on an empty item
+ * leaves the list, Tab and Shift-Tab nest and lift. Ctrl-Enter sends from
+ * anywhere, a list included. Nothing else: no headings, no bold — an
+ * assistant reads words. No look of its own: the host's element, the
+ * host's styles (`ChatInput` is the styled one).
+ *
+ *     <div emailChatInput placeholder="Tell the assistant what to change…"
+ *          [(value)]="instructions" (sent)="ask($event)" (escaped)="close()"></div>
+ *
+ * `value` is the text as it is sent — a line per block, list items as
+ * dash lines (`chatInputText`) — two-way: set it and the field shows it
+ * (a dash line becomes an item again). `sent` carries the same text;
+ * `clear()` empties the field, `focus()` puts the caret in it. A
+ * ProseMirror editor is mounted inside the element (the library's own,
+ * `.aee-editor`), so a host's editor styles reach it.
+ *
+ * **A signal-forms control, optionally.** It is a `FormValueControl` for
+ * `string`: bind a field with `[formField]="chat.message"` and the
+ * directive drives `value` both ways, pushes `disabled` and `readonly`
+ * in, hears `touch` when focus leaves the field, and `reset()` empties
+ * it. The form holds the *message*; the ask is still `sent` — an action
+ * with a stream behind it is the host's, not the form's submit.
+ */
+declare class ChatInputField implements FormValueControl<string> {
+    #private;
+    /** What the field is for, while it is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** The field's name for assistive technology. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Whether typing is refused. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the text is shown but not edited. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The text, as it is sent: lines, and `- ` dash lines for list items. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Enter (outside a list) or Ctrl-Enter: the text, as `value` has it.
+        Nothing is sent empty. The field keeps its text — the host clears it
+        (`clear()`) once the ask is on its way. */
+    readonly sent: _angular_core.OutputEmitterRef<string>;
+    /** Escape, in the field. */
+    readonly escaped: _angular_core.OutputEmitterRef<void>;
+    /** Focus left the field — a form marks it touched on this. */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    /** The editor inside, once mounted — for a host that wants more of it
+        than the text: its selection, a command, its `view`. */
+    readonly editor: _angular_core.Signal<Editor | null>;
+    constructor();
+    /** Empties the field. */
+    clear(): void;
+    /** A form's reset: the field, empty. */
+    reset(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInputField, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChatInputField, "[emailChatInput]", ["emailChatInput"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "sent": "sent"; "escaped": "escaped"; "touch": "touch"; }, never, never, true, never>;
+}
+/**
+ * The chat input, styled: `ChatInputField`'s behaviour in a box of its
+ * own — outlined on focus, growing and shrinking with its text in a short
+ * transition, scrolling past a height, disabled dimmed — the look
+ * tokenized (`--email-chat-input-*`, Material's system tokens beneath).
+ * The same inputs and outputs, forwarded; the same signal-forms contract.
+ *
+ *     <div email-chat-input placeholder="Tell the assistant what to change…"
+ *          [(value)]="instructions" (sent)="ask($event)" (escaped)="close()"></div>
+ *
+ * `field` is the directive underneath; `editor`, `clear()` and `focus()`
+ * are its, at hand.
+ *
+ * **The growing** (chat-input.animation.ts): the box follows the text's
+ * measured height through a `height` transition — `--email-chat-input-motion`
+ * is its duration and easing (`150ms ease`); reduced motion turns it off. The
+ * text grows to `--email-chat-input-max-height` (`5lh`, five lines) and
+ * then scrolls inside the box.
+ */
+declare class ChatInput {
+    /** The behaviour underneath: the field itself. */
+    readonly field: ChatInputField;
+    /** The editor inside, once mounted. */
+    readonly editor: _angular_core.Signal<Editor | null>;
+    constructor();
+    /** Empties the field. */
+    clear(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatInput, "div[email-chat-input]", never, {}, {}, never, never, true, [{ directive: typeof ChatInputField; inputs: { "placeholder": "placeholder"; "label": "label"; "disabled": "disabled"; "readonly": "readonly"; "value": "value"; }; outputs: { "valueChange": "valueChange"; "sent": "sent"; "escaped": "escaped"; "touch": "touch"; }; }]>;
+}
+
+export { ChatInput, ChatInputField, chatInputText };

package/types/h-k-dev-angular-email-editor-focus.d.ts

@@ -0,0 +1,40 @@
+import * as _angular_core from '@angular/core';
+
+/** Where a press may still take focus by default: real text entry. A field
+    inside a toolbar has to be typed in; everything else there is a tool. */
+declare const KEEP_FOCUS_EXCEPT = "input, textarea, select, [contenteditable]:not([contenteditable=\"false\"])";
+/**
+ * A press on this element never takes focus from wherever it is — the
+ * editor keeps its caret and its selection while a toolbar button, a menu
+ * row or a swatch is clicked, and whatever depends on the editor's focus (a
+ * bubble menu, a suggestion list) stays open through the click.
+ *
+ * Behaviour only: it renders nothing and sets no attribute, so it goes on a
+ * host's own elements — a Material button, an Aria toolbar, a CDK overlay's
+ * panel — or into a host's own component through `hostDirectives`:
+ *
+ *     <div role="toolbar" emailKeepFocus> … <button mat-icon-button>…</button> … </div>
+ *
+ *     @Component({ …, hostDirectives: [KeepFocus] })
+ *
+ * One on a container covers everything in it: the press bubbles. Only the
+ * pointer is kept out — Tab and the arrow keys still reach the tools, which
+ * is what makes them usable from the keyboard — and only the press: the
+ * click that follows runs as ever.
+ *
+ * It needs no editor: what keeps focus is whichever element has it, so the
+ * same directive serves a composer's address rows.
+ */
+declare class KeepFocus {
+    #private;
+    /** Off with `[emailKeepFocus]="false"`; on by its presence. */
+    readonly enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** What inside this element may still take focus on a press — a selector.
+        Text entry by default ({@link KEEP_FOCUS_EXCEPT}); `''` for nothing. */
+    readonly except: _angular_core.InputSignal<string>;
+    protected onMousedown(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeepFocus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KeepFocus, "[emailKeepFocus]", never, { "enabled": { "alias": "emailKeepFocus"; "required": false; "isSignal": true; }; "except": { "alias": "emailKeepFocusExcept"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { KEEP_FOCUS_EXCEPT, KeepFocus };

package/types/h-k-dev-angular-email-editor-image.d.ts

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { Editor } from '@h-k-dev/angular-email-editor';
+
+/**
+ * Makes the host's own text field the alt text of the editor's selected
+ * image — the image a click selected, or a drag over it alone
+ * (`selectedImage`). Everything but the field and its words is done:
+ *
+ *     <input dir="auto" [emailImageAlt]="editor" #alt="emailImageAlt"
+ *            (emailImageAltClosed)="open.set(false)" />
+ *     <button (click)="alt.apply()">Apply</button>
+ *
+ * - the field shows the image's alt, and again whenever another image is
+ *   selected; it is focused and selected as it appears, so typing replaces
+ *   it (`[emailImageAltAutoSelect]="false"` for a field that is always
+ *   there, a side panel's);
+ * - Enter applies — trimmed, and an emptied field takes the alt off — and
+ *   Escape puts the alt back as it was; both hand the caret back to the
+ *   editor (`[emailImageAltFocus]="false"` keeps it) and say so through
+ *   `emailImageAltClosed`: `true` applied, `false` not — the host's cue to
+ *   close its popover. Neither fires mid-composition: an IME's own Enter
+ *   and Escape stay the IME's;
+ * - `apply()` and `cancel()` are there for the host's buttons, `value()`
+ *   and `active()` for its bindings (an Apply that waits for a change).
+ *
+ * The field's words and direction are the host's: its label, its
+ * placeholder, and `dir="auto"` so an alt in a right-to-left script reads
+ * the right way round. The image stays selected throughout — the editor
+ * keeps its selection while the field has focus — so the popover can sit
+ * where the host likes.
+ */
+declare class ImageAlt {
+    #private;
+    /** The editor whose selected image this field describes. */
+    readonly editor: _angular_core.InputSignal<Editor | undefined>;
+    /** Whether the field takes focus, its text selected, as it appears. */
+    readonly autoSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the caret returns to the editor after an apply or a cancel. */
+    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Done with the field: `true` when the alt was applied, `false` when
+        not — cancelled, or no image to apply it to. */
+    readonly closed: _angular_core.OutputEmitterRef<boolean>;
+    /** Whether an image is selected at all — there is nothing to describe
+        otherwise, and `apply()` does nothing. */
+    readonly active: _angular_core.Signal<boolean>;
+    /**
+     * What the field says: the selected image's alt, until typing changes it
+     * — the draft. It starts over from the image whenever another one is
+     * selected or its alt changes elsewhere; typing changes no editor state,
+     * so it is never written over. Deliberately no write-back setter: the
+     * draft reaches the document once, on `apply()`, as one undo step — not
+     * a transaction per keystroke.
+     */
+    readonly value: _angular_core.WritableSignal<string>;
+    constructor();
+    /** Writes the draft to the selected image's alt. False when no image is
+        selected. */
+    apply(): boolean;
+    /** Leaves the alt as it was, and the field with it. */
+    cancel(): void;
+    protected onKey(event: Event, apply: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageAlt, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageAlt, "input[emailImageAlt], textarea[emailImageAlt]", ["emailImageAlt"], { "editor": { "alias": "emailImageAlt"; "required": true; "isSignal": true; }; "autoSelect": { "alias": "emailImageAltAutoSelect"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "emailImageAltFocus"; "required": false; "isSignal": true; }; }, { "closed": "emailImageAltClosed"; }, never, never, true, never>;
+}
+
+export { ImageAlt };

package/types/h-k-dev-angular-email-editor-material.d.ts

@@ -0,0 +1,65 @@
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+
+/**
+ * Makes an address input the control of an Angular Material form field —
+ * opt in per field, with the attribute:
+ *
+ * ```html
+ * <mat-form-field>
+ *   <mat-label>To</mat-label>
+ *   <div email-address-input emailMatFormField [formField]="envelope.to"></div>
+ *   <mat-hint>Separate addresses with a comma</mat-hint>
+ *   <mat-error>{{ envelope.to().errors()[0]?.message }}</mat-error>
+ * </mat-form-field>
+ * ```
+ *
+ * The directive is its own object, provided as the field's
+ * `MatFormFieldControl` — so the input's `value`, `disabled` and `required`
+ * stay the signal-forms contract they are, and nothing of Material reaches
+ * the input itself. What the field asks, it reads off the input:
+ *
+ * - **Label** — `for` the input's text field (`id`); it floats while the
+ *   field is focused or not `empty`: no chips *and* nothing typed.
+ * - **Errors** — `errorState` is invalid *and* touched: `mat-error` shows at
+ *   the moment the input starts flagging itself, never before.
+ * - **Hints and errors are read out** — their ids join the text field's
+ *   `aria-describedby`, beside any the host set itself.
+ * - **A click on the field** — anywhere in its box — puts the caret in.
+ *
+ * No `NgControl`: signal forms bind through `[formField]`, which the field
+ * does not need to know.
+ *
+ * The field's value is the input's — one header-form entry per recipient.
+ * A backend that keeps the header as one string gets it with
+ * `joinAddresses(list)` and hands it back through `splitAddresses(text)`
+ * (`@h-k-dev/angular-email-editor/address`); the pair round-trips entry for entry.
+ */
+declare class AddressFormField implements MatFormFieldControl<string[]> {
+    #private;
+    /** Tells the field to look again — whenever anything it reads moves. */
+    readonly stateChanges: Subject<void>;
+    readonly controlType = "email-address-input";
+    readonly ngControl: null;
+    constructor();
+    get value(): string[];
+    set value(value: string[] | null);
+    get id(): string;
+    get placeholder(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get required(): boolean;
+    get disabled(): boolean;
+    get errorState(): boolean;
+    /** The host's own `aria-describedby`, which the field keeps in its list. */
+    get userAriaDescribedBy(): string | undefined;
+    describedByIds: string[];
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddressFormField, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AddressFormField, "[email-address-input][emailMatFormField]", never, {}, {}, never, never, true, never>;
+}
+
+export { AddressFormField };