@h-k-dev/angular-email-editor 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,328 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import { FormValueControl, PathKind, SchemaPath, SchemaPathRules } from '@angular/forms/signals';
+import { AddressChipRemove, AddressChip } from '@h-k-dev/angular-email-editor/address-chip';
+import { AddressRules } from '@h-k-dev/angular-email-editor/address';
+
+/**
+ * The address input's label slot — opt in. By default the control owns no
+ * label: the template that holds the form draws the row and the label beside
+ * it, as it does for a plain `<input>`. A host that wants the label *inside*
+ * the control — at the start of the chips, the chips wrapping under it, the
+ * whole control one box (a Material form field around it, as iusta core
+ * writes its rows) — hands the control a template:
+ *
+ *     <div email-address-input [formField]="envelope.to">
+ *       <ng-template emailAddressLabel>To</ng-template>
+ *     </div>
+ *
+ * The control renders it first in its row, in a box of its own
+ * (`[data-slot=label]`), and names its text input by it — unless the host
+ * named the input itself (`aria-labelledby` / `aria-label`).
+ */
+declare class AddressInputLabel {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressInputLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AddressInputLabel, "ng-template[emailAddressLabel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * An address field the way Gmail's works: committed addresses as chips,
+ * free typing after them. Enter, comma, semicolon or a paste commits what
+ * was typed — a comma or semicolon inside a quoted name or angle brackets is
+ * just typed, and no key commits while an IME is composing; Backspace on the empty input takes the chip before the caret
+ * back for editing; `limit` caps the count (From takes one) and hides the
+ * input once reached.
+ *
+ * **Only an address becomes a chip while typing.** Enter, comma, semicolon,
+ * Tab and a paste commit the addresses in what was typed and leave the rest —
+ * what is not an address yet — in the input, flagged, for the user to
+ * finish. Leaving the field commits everything, so the form sees the typo
+ * and flags it; and focus coming back hands the malformed entries at the
+ * end of the list straight back to the input, as plain typing again.
+ *
+ * **The input is always at the end, and editing happens there.** A chip
+ * taken back for editing — a double click, Enter on a picked chip,
+ * Backspace, `edit()` — leaves its place: its address goes into the input,
+ * after the last chip, exactly like a typo the field handed back — and what
+ * is committed from it joins the end of the list. There is one place where
+ * text is typed, and it never moves.
+ *
+ * **One pending edit at a time.** There is only ever one thing being fixed,
+ * and it is what the caret is on. Starting another edit — `edit()`, Enter
+ * on a picked chip, Backspace taking the chip before the caret back — ends
+ * the one pending: a typo left in the input and any chip that is not an
+ * address go.
+ *
+ * **Chips while focused, a line of text otherwise.** With focus elsewhere
+ * the addresses read as a comma-separated line — no surface, no buttons;
+ * focus in the input turns them into chips.
+ *
+ * **The arrow keys rove the chips; the caret stays in the input.** With
+ * the caret at the start of the typing, ← puts a highlight on the last chip
+ * and walks back along the list; → walks forward, and past the last chip
+ * returns to the caret. Enter or F2 — or a double click on
+ * any chip — edits it,
+ * Backspace or Delete removes it, Escape drops the highlight, and so does
+ * typing. A click on a chip highlights it. Reaching a chip either way is
+ * being done with the typing: an address in the input becomes a chip first,
+ * as Enter would make it. The highlight is
+ * `aria-activedescendant` on the input and `aria-current` on the chip, and the
+ * chips' remove buttons stay out of the tab order — Tab lands on the input —
+ * except when the field is full and has no input to land on.
+ *
+ * A display name is kept — `Ada Lovelace <ada@example.com>` is one chip
+ * that shows "Ada Lovelace" — and the value stays `string[]` in header
+ * form, ready for a `To:` line. Typed bare, `Ada Lovelace ada@example.com`
+ * becomes that same chip. An address is in the list once: another entry
+ * with the same address — in any case, under any name — is dropped.
+ *
+ * **The control, not the row.** By default it owns no label and draws no row: the
+ * template that holds the form puts it in a row of its own making, beside a
+ * label of its own making, exactly as it does for a plain `<input>` — and
+ * names the control through `aria-labelledby` (the label's id) or
+ * `aria-label`, which land on the text input inside, the element assistive
+ * tech reaches. Clicking anywhere on the control puts the caret in; a row
+ * that wants its label to do the same calls `focus()`.
+ *
+ * **A signal-forms control, optionally.** It implements `FormValueControl`
+ * for `string[]`: bind a field with `[formField]="envelope.to"` and the
+ * directive drives `value` both ways, pushes `invalid`, `touched`,
+ * `disabled`, `readonly`, `required` and `name` in, and hears `touch` when
+ * focus leaves the input. Without a form, `[(value)]` alone is the whole
+ * contract; the state inputs are optional and the chips still flag a
+ * malformed address on their own. The rules that go with it — `addressList`
+ * — live beside it, because the built-in `required` and `email` know
+ * nothing of an array of mailboxes.
+ *
+ * **No messages of its own.** The control reflects the field's state —
+ * invalid *and* touched, so nothing shouts before the user has left it —
+ * and a malformed address is flagged on its chip; wording what is wrong is
+ * the job of the component that owns the form, which has the errors.
+ *
+ * **Parts are `data-slot`s** — `chips`, `entry`, `input` — plus the chips'
+ * own; that is how the control is styled from outside: theme it through
+ * the `--email-*` tokens, and reach a part for a structural override with
+ * two attributes.
+ *
+ * **The selection and its commands are public.** A host's own controls —
+ * a bar over the writer, the way a phone's action bar sits over the app
+ * bar — work the picked chip through `current()` and `select()` for the
+ * state and `edit()`, `remove()` and `copy()` for the commands, each on the
+ * current chip unless given another. Such a bar's buttons must decline
+ * their mousedown (`(mousedown)="$event.preventDefault()"`): focus stays in
+ * the input, and the selection with it — focus leaving the control clears
+ * the selection.
+ *
+ * **The chips' remove control is a template slot.** An
+ * `ng-template[emailAddressChipRemove]` in the input's content is handed to
+ * every chip it renders, in place of the default × button.
+ *
+ * **State on the host.** `aria-disabled` while disabled; `data-invalid`
+ * while invalid and touched; `data-full` once `limit` is reached;
+ * `data-focused` while focus is anywhere in the control. The text input
+ * carries `data-refused` while it holds text a commit left behind.
+ *
+ * No Material, no icon font, no headless library. It holds the list it
+ * shows and nothing else: contacts, lookups and sending are the host's.
+ */
+declare class AddressInput implements FormValueControl<string[]> {
+    #private;
+    /** The committed addresses, in header form. Two-way; the form's value. */
+    readonly value: _angular_core.ModelSignal<string[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** The id of the row's label, passed through to the text input — the
+        host's label, wherever the host put it. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /** A name for the text input when there is no visible label. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** The ids of whatever describes the field — a hint, an error line —
+        passed through to the text input, where assistive tech reads them. */
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    /** What the text input's `aria-describedby` says: the host's own ids and a
+        frame's, each once. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Adds the ids of a frame's own lines — a form field's hint and error —
+        to what describes the text input, beside the host's `aria-describedby`;
+        each call replaces the frame's previous ids. */
+    describe(ids: readonly string[]): void;
+    /** Most addresses the field takes; the input hides once reached. Named
+        `limit`, not `max`: the form contract keeps that name for the `max` rule. */
+    readonly limit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Prefix for each chip's remove button — "Remove ada@example.com". */
+    readonly removeLabel: _angular_core.InputSignal<string>;
+    /** What a malformed address is flagged as. */
+    readonly invalidLabel: _angular_core.InputSignal<string>;
+    /** The chips' note on a placeholder a template fills in later. */
+    readonly pendingLabel: _angular_core.InputSignal<string>;
+    /** The input's `name` attribute; the directive derives one from the path. */
+    readonly name: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Focus left the input. The directive marks the field touched on it. */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    /** The text input's id, for a host label's `for`. */
+    readonly id: string;
+    /** The host's label template, if it opted into one — rendered first in
+        the row; the text input is named by it. */
+    protected readonly labelSlot: _angular_core.Signal<AddressInputLabel | undefined>;
+    /** The label box's id, for the text input's `aria-labelledby`. */
+    protected readonly labelId: string;
+    /** What names the text input: the host's own `aria-labelledby`; else the
+        label slot — unless the host gave an `aria-label` instead. */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** The host's remove template, passed on to every chip. */
+    protected readonly removeSlot: _angular_core.Signal<AddressChipRemove | undefined>;
+    protected readonly field: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    /** Focus is somewhere in the control — the input or a chip's remove
+        button. The chips are chips only then. Read-only; for a host's own
+        frame (a form field whose label floats on it). */
+    readonly focused: _angular_core.Signal<boolean>;
+    /** What is typed in the input and not committed yet — for a host's own
+        frame, where a field with typing in it is not empty. */
+    readonly text: _angular_core.Signal<string>;
+    /** The input holds text a commit left behind: not an address yet. */
+    protected readonly refused: _angular_core.WritableSignal<boolean>;
+    /** The chip the arrow keys or a click picked, by index in the value — the
+        one Enter, Backspace and Delete act on while the caret stays in the
+        input. */
+    protected readonly active: _angular_core.WritableSignal<number | null>;
+    /** The picked chip's address — the one the arrow keys or a click reached
+        and the commands act on — or null. Public, for a host's own controls. */
+    readonly current: _angular_core.Signal<string | null>;
+    /** Picks a chip by address, or none. */
+    select(address: string | null): void;
+    /** The chips as rendered, for the commands that are the chip's own. */
+    protected readonly chips: _angular_core.Signal<readonly AddressChip[]>;
+    /** The active chip's id, for the input's `aria-activedescendant`. */
+    protected readonly activeId: _angular_core.Signal<string | null>;
+    protected chipId(index: number): string;
+    /** The cap is reached: a further address is refused. */
+    readonly full: _angular_core.Signal<boolean>;
+    /** Full, and nothing in it to fix: the input hides — the chips say
+        everything. A full list ending in a typo keeps it, so focus can hand
+        the typo back. */
+    protected readonly closed: _angular_core.Signal<boolean>;
+    /** Nothing may change: disabled or read-only. Chips lose their remove
+        button, the input is out of play. */
+    protected readonly locked: _angular_core.Signal<boolean>;
+    /** Invalid *and* touched — the moment the state becomes the user's business. */
+    protected readonly flagged: _angular_core.Signal<boolean>;
+    /** Splits a run into addresses and adds the new ones to the end of the
+        list, up to `limit`. Duplicates — by address, case-insensitively —
+        are dropped; a malformed one is kept and
+        flagged — this is the host's way in, and the host decides what it
+        holds. */
+    commit(raw: string): void;
+    /** Drops one address — the picked chip's by default. Identity by string:
+        the list never holds the same header form twice, so this takes exactly
+        the chip that asked. */
+    remove(address?: string | null): void;
+    /** A chip's remove control was used: the address goes, and the caret
+        comes back to the input — the focused button went with its chip, and
+        focus left on nothing would strand a keyboard user and read to a host
+        as the field being left. */
+    protected removeChip(address: string): void;
+    /** Takes a chip — the picked one by default — back for editing: it
+        leaves the list and the input, at the end, holds its address, caret at
+        the end. The edit pending until now ends first. A locked list edits
+        nothing. */
+    edit(address?: string | null, input?: HTMLInputElement): void;
+    /** Puts the caret in the input — the whole control is the field, and a
+        host's label row may forward its own clicks here. A full field has no
+        input to put it in: focus goes to the last chip's remove control. */
+    focus(): void;
+    /** A press anywhere on the control is the input's from that moment: it
+        takes focus at the press, not at the click after the release — so a
+        chip pressed in a line of text turns the line to chips at once, and a
+        hold on a chip runs with the document focused, which the clipboard
+        insists on. `keepCaret` then declines the press's own default, which
+        would move focus off again. */
+    protected onPointerdown(event: PointerEvent): void;
+    /** A press anywhere on the control but the text input itself — a chip,
+        its button, the gap between — leaves the caret where it is. The
+        browser would otherwise move focus to the body for the press and back
+        on the click, and in that instant the row would drop to text and
+        reflow: a flash, and a blur that commits and touches for nothing. */
+    protected keepCaret(event: MouseEvent): void;
+    /** A click on a chip — not on its remove control — picks it, and only
+        that: a click on the picked chip picks it again. The caret is in the
+        input either way. */
+    protected onChipClick(event: MouseEvent, index: number, input: HTMLInputElement): void;
+    /** A double click on a chip — not on its remove control — takes it back
+        for editing. */
+    protected onChipDblclick(event: MouseEvent, address: string, input: HTMLInputElement): void;
+    /** Copies a chip's address — the picked one by default — to the
+        clipboard, as a hold on the chip does; the chip shows and says so.
+        Resolves to whether the copy went. */
+    copy(address?: string | null): Promise<boolean>;
+    protected onFocusin(): void;
+    protected onInput(input: HTMLInputElement): void;
+    protected onKeydown(event: KeyboardEvent, input: HTMLInputElement): void;
+    /** A paste of several addresses: the addresses become chips, the rest
+        joins what the input already holds. A single token is left to the
+        input, so a name with spaces can still be edited before it commits. */
+    protected onPaste(event: ClipboardEvent, input: HTMLInputElement): void;
+    /** Focus arrived in the input: the typos at the end of the list come back
+        into it, to be fixed — unless the user is already typing there. They
+        come back as plain typing, not flagged: the caret is on them, and the
+        next commit judges them again. */
+    protected onFocus(input: HTMLInputElement): void;
+    /** Leaving the field commits everything typed — the addresses, then a
+        typo at the end of the list, so the form sees it and the next focus
+        hands it back — and is the touch. Moving to a chip's remove button is
+        not leaving. */
+    protected onBlur(event: FocusEvent, input: HTMLInputElement): void;
+    protected onFocusout(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddressInput, "[email-address-input]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "invalidLabel": { "alias": "invalidLabel"; "required": false; "isSignal": true; }; "pendingLabel": { "alias": "pendingLabel"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, ["labelSlot", "removeSlot"], never, true, never>;
+}
+
+/** The error kinds `addressList` reports, for a host that switches on them. */
+declare const ADDRESS_LIST_EMPTY = "addressList.empty";
+declare const ADDRESS_LIST_INVALID = "addressList.invalid";
+declare const ADDRESS_LIST_TOO_MANY = "addressList.tooMany";
+interface AddressListOptions {
+    /** Fewest addresses the list must hold. 1 by default; 0 for Cc and Bcc. */
+    readonly min?: number;
+    /** Most addresses the list may hold. Unbounded by default; 1 for From. */
+    readonly max?: number;
+    /** The address rule to judge by. By default the one in force where the
+        form is made (`provideAddressRules`), else ours. */
+    readonly rules?: AddressRules;
+    /** The messages, for a host that words them itself or translates them. */
+    readonly messages?: {
+        readonly empty?: (min: number) => string;
+        readonly invalid?: (offenders: readonly string[]) => string;
+        readonly tooMany?: (max: number) => string;
+    };
+}
+/**
+ * The rule an address field needs and the built-ins cannot give it:
+ * `required` takes an empty array for a value, and `email` validates one
+ * string. This validates a `string[]` of mailboxes in header form — the
+ * address input's value — as a list: at least `min` of them (one, unless
+ * told otherwise), at most `max`, and every one a well-formed address, with
+ * the offenders named in the message so a chip can be found and fixed. A
+ * placeholder a template fills in later (`{{contact.email}}`, by the rule's
+ * `isPlaceholder`) is no offender — it counts toward `min` and `max`;
+ * whether it may still be sent unresolved is the host's call.
+ *
+ * ```ts
+ * const envelope = form(model, (p) => {
+ *   addressList(p.from, { max: 1 });
+ *   addressList(p.to);
+ *   addressList(p.cc, { min: 0 });
+ * });
+ * ```
+ *
+ * Errors carry a `kind` from the `ADDRESS_LIST_*` constants and a `message`
+ * the input shows; pass `messages` to word or translate them.
+ */
+declare function addressList<TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<string[], SchemaPathRules.Supported, TPathKind>, options?: AddressListOptions): void;
+
+export { ADDRESS_LIST_EMPTY, ADDRESS_LIST_INVALID, ADDRESS_LIST_TOO_MANY, AddressInput, AddressInputLabel, addressList };
+export type { AddressListOptions };

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

@@ -0,0 +1,125 @@
+import { InjectionToken, Provider } from '@angular/core';
+
+/**
+ * A mailbox the way a header spells it: an address, and the display name a
+ * client shows in front of it — `Ada Lovelace <ada@example.com>`,
+ * `"Lovelace, Ada" <ada@example.com>`, or the bare `ada@example.com`.
+ *
+ * The chips hold that header form as one string, so a host's `string[]`
+ * carries names without a second type and goes into a `To:` header as it
+ * is.
+ */
+interface Mailbox {
+    /** The display name, if the mailbox has one; quotes already removed. */
+    readonly name?: string;
+    readonly address: string;
+}
+/**
+ * The address rule — what an address is, how a mailbox is read and written,
+ * how typed text splits into mailboxes. The library's own is `rules.ts`
+ * ({@link defaultAddressRules}); a host with a rule of its own — a stricter
+ * validator, an established parser, the rule its backend already enforces —
+ * provides it with {@link provideAddressRules}, whole or in part, and every
+ * address piece asks it instead: the input, the chip, the `addressList`
+ * form rule, and (passed as an option) `replyEnvelope` and
+ * `toInboundMessage`.
+ */
+interface AddressRules {
+    /** A typed, pasted or header run as mailboxes in header form. */
+    split(raw: string): string[];
+    /** A header-form mailbox as its name and address. */
+    parse(raw: string): Mailbox;
+    /** A mailbox in header form, the name quoted where it has to be. */
+    format(mailbox: Mailbox): string;
+    /** Whether a bare address — no name, no brackets — is well-formed. */
+    isValid(address: string): boolean;
+    /** Whether an address is a placeholder a template fills in later
+        (`{{contact.email}}`) — neither valid nor invalid until then. A host
+        that sends what is typed, unresolved, turns it off with
+        `provideAddressRules({ isPlaceholder: () => false })`. */
+    isPlaceholder(address: string): boolean;
+    /** What makes two addresses one recipient: equal identities are. */
+    identity(address: string): string;
+}
+/** The address rule in force — ours unless a host provides its own. */
+declare const ADDRESS_RULES: InjectionToken<AddressRules>;
+/**
+ * Puts a host's address rule in force: the parts given replace ours, the
+ * rest stay ours. Keeping an existing validator is one line:
+ *
+ * ```ts
+ * providers: [provideAddressRules({ isValid: isValidEmail })]
+ * ```
+ */
+declare function provideAddressRules(rules: Partial<AddressRules>): Provider;
+/** Whether a header-form string is a mailbox whose address is well-formed. */
+declare function isMailbox(raw: string, rules?: AddressRules): boolean;
+/** Whether a header-form entry's address is a placeholder — pending: a
+    template fills it in later, so it is no mistake to flag. */
+declare function isPending(raw: string, rules?: AddressRules): boolean;
+/** What makes two header-form entries one recipient — the name in front of
+    the address makes no second one. For a list that holds each recipient
+    once. */
+declare function addressKey(raw: string, rules?: AddressRules): string;
+/**
+ * A list of header-form entries as one header value — `"Müller, Hans"
+ * <h@x.de>, b@c.de` — for a backend or a template that keeps To, Cc and Bcc
+ * as text. The way back is the rule's own `split`: `rules.split(joined)` is
+ * the list again, entry for entry. A well-formed mailbox is written in its
+ * canonical form (a name with a comma quoted); anything else — a typo, a
+ * `{{placeholder}}` — goes in as it is, for the backend to resolve or refuse.
+ *
+ * ```ts
+ * to: joinAddresses(form.to().value()),           // out to the backend
+ * form.to().value.set(splitAddresses(template.to)) // back in
+ * ```
+ */
+declare function joinAddresses(list: readonly string[], rules?: AddressRules): string;
+
+/** Whether a bare address — no name, no brackets — is well-formed by the
+    rule above. */
+declare function isEmailAddress(address: string): boolean;
+/** Whether a separator typed at `caret` would separate — false inside a
+    quoted name, a comment or angle brackets, where a comma is part of the
+    mailbox: `"Lovelace, Ada"`. */
+declare function separatesAt(raw: string, caret: number): boolean;
+/**
+ * Splits a header-form mailbox into name and address: quoted strings
+ * unquoted and unescaped, encoded words decoded, comments skipped — or, after
+ * a bare address, taken as its name — and an obsolete route dropped.
+ * Anything that is no mailbox comes back as its trimmed text, as the address,
+ * for the rule to refuse.
+ */
+declare function parseMailbox(raw: string): Mailbox;
+/** The header form of a mailbox — the name quoted (and escaped) when it has
+    to be. UTF-8 stays as it is (RFC 6532); a mailer encodes for the wire. */
+declare function formatMailbox(mailbox: Mailbox): string;
+/**
+ * Splits a typed, pasted or header run into mailboxes — see the leniencies
+ * above. A well-formed mailbox comes back in its canonical header form
+ * (`<a@x.io>` → `a@x.io`, `Dr. Ada <a@x.io>` → `"Dr. Ada" <a@x.io>`, a
+ * comment or an encoded word turned into the name); anything else comes back
+ * as typed, for the user to fix. Empty tokens are dropped; duplicates are
+ * the caller's.
+ */
+declare function splitAddresses(raw: string): string[];
+/**
+ * What makes two entries one recipient. The domain is case-insensitive and
+ * compared in its ASCII form (`müller.de` is `xn--mller-kva.de`); the local
+ * part is lowercased too — RFC 5321 lets a server tell `Ada` from `ada`, no
+ * real one does, and one recipient twice is the mistake that matters. Both
+ * NFC-normalized, so a composed and a decomposed `ü` are one.
+ */
+declare function addressIdentity(address: string): string;
+/** Decodes the RFC 2047 encoded words in a header text; one that cannot be
+    decoded stays as it is. Two encoded words only whitespace separates are
+    joined with none. */
+declare function decodeEncodedWords(text: string): string;
+/** Whether an address holds a `{{…}}` placeholder — one a template fills
+    in later, so neither valid nor invalid yet. */
+declare function isAddressPlaceholder(address: string): boolean;
+/** Our rule, as the contract every part of the library asks through. */
+declare const defaultAddressRules: AddressRules;
+
+export { ADDRESS_RULES, addressIdentity, addressKey, decodeEncodedWords, defaultAddressRules, formatMailbox, isAddressPlaceholder, isEmailAddress, isMailbox, isPending, joinAddresses, parseMailbox, provideAddressRules, separatesAt, splitAddresses };
+export type { AddressRules, Mailbox };

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

@@ -0,0 +1,44 @@
+import * as _angular_core from '@angular/core';
+
+/** A box in viewport coordinates — a `DOMRect`, a menu state's
+    `boundingBox`, a caret's `coordsAtPos`. A point when it has no size. */
+interface AnchorRect {
+    left: number;
+    top: number;
+    width?: number;
+    height?: number;
+}
+/**
+ * A real element kept over a box the editor reports — a selection, a caret,
+ * a block. The editor knows rectangles; everything that floats wants an
+ * *element* to hold on to: the CDK's `cdkOverlayOrigin`, Material's
+ * `matMenuTriggerFor`, Aria's menu trigger, CSS anchor positioning,
+ * Floating UI. This is that element, so each of them works as it is:
+ *
+ *     <span [emailAnchor]="state().boundingBox" cdkOverlayOrigin #origin="cdkOverlayOrigin"></span>
+ *     <ng-template cdkConnectedOverlay [cdkConnectedOverlayOrigin]="origin" …>
+ *
+ * Behaviour only: it places its element — fixed, at the box, out of the
+ * pointer's way — and renders nothing. While the box is `null` it stays
+ * where it last was, so what is anchored to it can close (and animate out)
+ * in place rather than jump to the corner.
+ *
+ * The box is in viewport coordinates, so the element is `position: fixed`;
+ * it must not sit inside a transformed ancestor, which would become its
+ * frame. It does not follow a scroll by itself: it is as current as the box
+ * it is given.
+ */
+declare class Anchor {
+    /** The box to stand over; `null` while there is none. */
+    readonly rect: _angular_core.InputSignal<AnchorRect | null | undefined>;
+    /** The element itself — for what takes an element rather than a template
+        reference (`#anchor="emailAnchor"`, then `anchor.element`). */
+    readonly element: HTMLElement;
+    /** The box being stood over: the last one given, held through `null`. */
+    protected readonly box: _angular_core.WritableSignal<Required<AnchorRect>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Anchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Anchor, "[emailAnchor]", ["emailAnchor"], { "rect": { "alias": "emailAnchor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Anchor };
+export type { AnchorRect };