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

package/package.json

@@ -1,6 +1,136 @@
 {
   "name": "@h-k-dev/angular-email-editor",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "An email editor for Angular on ProseMirror — a visual composer and an HTML source editor over one schema that is the vocabulary of email HTML.",
+  "license": "MIT",
+  "author": "h-k-dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/h-k-dev/angular-email-editor.git",
+    "directory": "projects/angular-email-editor"
+  },
+  "homepage": "https://h-k-dev.github.io/angular-email-editor/",
+  "bugs": "https://github.com/h-k-dev/angular-email-editor/issues",
+  "keywords": [
+    "angular",
+    "email",
+    "email-editor",
+    "prosemirror",
+    "wysiwyg",
+    "html-email",
+    "rich-text",
+    "signals"
+  ],
+  "peerDependencies": {
+    "@angular/common": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/forms": "^22.0.0",
+    "@angular/material": "^22.0.0",
+    "@chenglou/pretext": "^1.0.0",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-gapcursor": "^1.4.1",
+    "prosemirror-history": "^1.5.0",
+    "prosemirror-inputrules": "^1.5.1",
+    "prosemirror-keymap": "^1.2.3",
+    "prosemirror-model": "^1.25.9",
+    "prosemirror-schema-list": "^1.5.1",
+    "prosemirror-state": "^1.4.4",
+    "prosemirror-tables": "^1.8.5",
+    "prosemirror-transform": "^1.12.0",
+    "prosemirror-view": "^1.41.9",
+    "rxjs": "^7.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/forms": {
+      "optional": true
+    },
+    "@angular/material": {
+      "optional": true
+    },
+    "@chenglou/pretext": {
+      "optional": true
+    },
+    "rxjs": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "exports": {
+    "./styles/*": {
+      "sass": "./styles/_*.scss"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/h-k-dev-angular-email-editor.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor.mjs"
+    },
+    "./actions": {
+      "types": "./types/h-k-dev-angular-email-editor-actions.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-actions.mjs"
+    },
+    "./address": {
+      "types": "./types/h-k-dev-angular-email-editor-address.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-address.mjs"
+    },
+    "./address-chip": {
+      "types": "./types/h-k-dev-angular-email-editor-address-chip.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-address-chip.mjs"
+    },
+    "./address-input": {
+      "types": "./types/h-k-dev-angular-email-editor-address-input.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-address-input.mjs"
+    },
+    "./anchor": {
+      "types": "./types/h-k-dev-angular-email-editor-anchor.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-anchor.mjs"
+    },
+    "./attachment-chip": {
+      "types": "./types/h-k-dev-angular-email-editor-attachment-chip.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-attachment-chip.mjs"
+    },
+    "./attachment-chips": {
+      "types": "./types/h-k-dev-angular-email-editor-attachment-chips.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-attachment-chips.mjs"
+    },
+    "./chat-input": {
+      "types": "./types/h-k-dev-angular-email-editor-chat-input.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-chat-input.mjs"
+    },
+    "./focus": {
+      "types": "./types/h-k-dev-angular-email-editor-focus.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-focus.mjs"
+    },
+    "./image": {
+      "types": "./types/h-k-dev-angular-email-editor-image.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-image.mjs"
+    },
+    "./material": {
+      "types": "./types/h-k-dev-angular-email-editor-material.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-material.mjs"
+    },
+    "./metrics": {
+      "types": "./types/h-k-dev-angular-email-editor-metrics.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-metrics.mjs"
+    },
+    "./palette": {
+      "types": "./types/h-k-dev-angular-email-editor-palette.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-palette.mjs"
+    },
+    "./proposal": {
+      "types": "./types/h-k-dev-angular-email-editor-proposal.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-proposal.mjs"
+    },
+    "./suggestion-menu": {
+      "types": "./types/h-k-dev-angular-email-editor-suggestion-menu.d.ts",
+      "default": "./fesm2022/h-k-dev-angular-email-editor-suggestion-menu.mjs"
+    }
+  },
+  "sideEffects": false,
+  "module": "fesm2022/h-k-dev-angular-email-editor.mjs",
+  "typings": "types/h-k-dev-angular-email-editor.d.ts",
+  "type": "module"
 }

package/styles/_scroll.scss

@@ -0,0 +1,101 @@
+// The library's scrollbar, for anything that scrolls — after iusta-core's
+// `.iusta-scroll`, on our own tokens. A thin, round thumb on no track, out
+// of sight until the pointer is over the scroller or the focus is in it
+// (always there where nothing hovers: a touch screen); a stable gutter, so
+// the thumb coming and going never moves the content; sideways overscroll
+// kept in the scroller, so a pane scrolled to its edge never swipes the
+// page back a page.
+//
+//     @use '@h-k-dev/angular-email-editor/styles/scroll';
+//
+//     .pane {
+//       overflow-y: auto;
+//       @include scroll.scroll;
+//     }
+//
+// A mixin, not a class: nothing reaches a stylesheet that does not include
+// it. Tokens — `--email-scroll-*` first, then Material's system token of the
+// same meaning, then a fallback:
+//
+// - `--email-scroll-size` — the thumb's thickness and the gutter's (6px).
+// - `--email-scroll-thumb` — the thumb at rest (the outline variant at 50%).
+// - `--email-scroll-thumb-hover` — under the pointer (at 75%).
+// - `--email-scroll-track` — the track (transparent).
+//
+// **Smooth scrolling is opt-in** (`$smooth: true`, and then only without
+// reduced motion). Most of what scrolls here is driven by a caret or by keys —
+// an editor following its caret, a menu following its active row — and a
+// smooth scroll there animates every one of those nudges: arrowing past the
+// edge reads as lag, a held key queues animations behind the cursor. iusta
+// turned it on everywhere and turns it off one scroller at a time; here it
+// is the other way round. Only a scroller a person drags or jumps through
+// by link wants it.
+//
+// Webkit and Blink draw the thumb from `::-webkit-scrollbar`; Firefox, which
+// has no pseudo-elements for it, gets the standard `scrollbar-width` and
+// `scrollbar-color` — kept to Firefox, because in Chrome either one switches
+// the pseudo-elements, and so the thickness and the round thumb, off.
+
+$_outline-variant: var(--mat-sys-outline-variant, light-dark(#c4c7c5, #444746));
+
+@mixin scroll($smooth: false) {
+  --_email-scroll-size: var(--email-scroll-size, 6px);
+  --_email-scroll-thumb: var(
+    --email-scroll-thumb,
+    color-mix(in srgb, #{$_outline-variant} 50%, transparent)
+  );
+  --_email-scroll-thumb-hover: var(
+    --email-scroll-thumb-hover,
+    color-mix(in srgb, #{$_outline-variant} 75%, transparent)
+  );
+  // The thumb's colour now: none until the scroller is in use. Declared on
+  // every scroller, so a nested one starts out of sight however its outer
+  // one stands.
+  --_email-scroll-current: transparent;
+
+  scrollbar-gutter: stable;
+  overscroll-behavior-x: contain;
+
+  @supports (-moz-appearance: none) {
+    scrollbar-width: thin;
+    scrollbar-color: var(--_email-scroll-current) var(--email-scroll-track, transparent);
+  }
+
+  &::-webkit-scrollbar {
+    width: var(--_email-scroll-size);
+    height: var(--_email-scroll-size);
+  }
+
+  &::-webkit-scrollbar-track {
+    background: var(--email-scroll-track, transparent);
+  }
+
+  &::-webkit-scrollbar-corner {
+    background: transparent;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background-color: var(--_email-scroll-current);
+    border-radius: 1e3px;
+  }
+
+  &:hover,
+  &:focus-within {
+    --_email-scroll-current: var(--_email-scroll-thumb);
+
+    &::-webkit-scrollbar-thumb:hover {
+      background-color: var(--_email-scroll-thumb-hover);
+    }
+  }
+
+  // Nothing hovers on a touch screen: the thumb is simply there.
+  @media (hover: none) {
+    --_email-scroll-current: var(--_email-scroll-thumb);
+  }
+
+  @if $smooth {
+    @media (prefers-reduced-motion: no-preference) {
+      scroll-behavior: smooth;
+    }
+  }
+}

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

@@ -0,0 +1,147 @@
+import * as _angular_core from '@angular/core';
+import { Signal, Injector } from '@angular/core';
+import { EditorState } from 'prosemirror-state';
+import { EditorAction, Editor } from '@h-k-dev/angular-email-editor';
+
+/**
+ * An editor's state as a signal: the text, the selection, the stored marks —
+ * whatever changed, the signal has the new one. It follows the editor it is
+ * given, so handing it "the source pane in code view, the email editor
+ * otherwise" is one `computed`; `undefined` while there is none.
+ *
+ * It listens through `editor.subscribe`, so the editor can already exist:
+ * nothing has to be in the kit before the editor is made.
+ *
+ * Call in an injection context, or hand it an injector.
+ */
+declare function editorState(editor: () => Editor | undefined, options?: {
+    injector?: Injector;
+}): Signal<EditorState | undefined>;
+/**
+ * An action of the host's own: something that opens its UI — a link dialog,
+ * a colour or table picker — rather than running a command. It has a `run`,
+ * not a `command`, on purpose: a command is *asked* whether it would apply
+ * (called without a dispatch), and a function that opens a dialog must never
+ * be called to ask.
+ *
+ * Two ways in, by what it is:
+ * - `host` — an action of its own, there for every editor: "Link", which
+ *   no extension can offer because it needs the host's dialog;
+ * - `override` — the host's `run` *over* an action the kit declares, by its
+ *   id: a toolbar's "Insert table" that opens a size picker instead of
+ *   inserting one. It exists only where the kit's action does (so not in a
+ *   code view), and what it leaves out — when it is on, whether it can run —
+ *   is still the extension's answer.
+ */
+interface HostAction {
+    id: string;
+    /** What triggering it does. Focus is the host's from here on: the caret
+        is not sent back to the editor after it. */
+    run: () => void;
+    /** On at the selection — makes it a toggle. */
+    isActive?: (state: EditorState) => boolean;
+    /** Can run right now. Absent: the extension action's answer when it
+        stands over one, else yes. */
+    isEnabled?: (state: EditorState) => boolean;
+}
+/** An action bound to a live editor: what a button needs. */
+interface BoundAction {
+    /** The action as its extension declared it — id, title, icon, keywords;
+        `undefined` for a {@link HostAction} that stands alone. */
+    readonly action: EditorAction | undefined;
+    readonly id: string;
+    /** It is the host's `run`: what happens after — where focus goes — is the
+        host's too. */
+    readonly external: boolean;
+    /** On at the selection. Always false for an action with no "on". */
+    readonly pressed: Signal<boolean>;
+    /** Whether it is a toggle at all — whether `pressed` means anything. */
+    readonly toggles: boolean;
+    /** Cannot run right now. */
+    readonly disabled: Signal<boolean>;
+    /** Runs it on the editor; false when it did not apply. */
+    run(): boolean;
+    /** Puts the caret back in the editor it acts on. */
+    focus(): void;
+}
+/** The actions of the editor being watched. */
+interface EditorActions {
+    /** The action of that id — `undefined` while there is no editor, and when
+        the editor's kit has no such action: a button for it has nothing to do.
+        Reactive: it follows the editor. */
+    get(id: string): BoundAction | undefined;
+    /** Every action of the current editor, in kit order. */
+    readonly all: Signal<readonly BoundAction[]>;
+    /** The watched editor's state. */
+    readonly state: Signal<EditorState | undefined>;
+}
+/**
+ * The actions of an editor, bound and live — for a toolbar, a bubble menu,
+ * a menu:
+ *
+ *     readonly actions = injectActions(() => this.editor());
+ *
+ *     <button [emailAction]="actions.get('bold')">…</button>
+ *
+ * `editor` is read reactively: when it changes — a composer switching to its
+ * code view — the actions are the new editor's. Its kit decides what exists:
+ * the source pane offers the marks, so there a list button has no action
+ * and shows disabled, with no routing written anywhere.
+ *
+ * `host` and `override` bring in the host's own — see {@link HostAction} — so
+ * that one list serves a surface whose buttons are not all the editor's.
+ *
+ * Call in an injection context, or hand it an injector.
+ */
+declare function injectActions(editor: () => Editor | undefined, options?: {
+    host?: readonly HostAction[];
+    override?: Readonly<Record<string, Omit<HostAction, 'id'>>>;
+    injector?: Injector;
+}): EditorActions;
+
+/**
+ * Makes the host's own control the trigger of an editor action: a click runs
+ * it, and the control says what the action's state is.
+ *
+ *     <button mat-icon-button [emailAction]="actions.get('bold')" #bold="emailAction"
+ *             [disabled]="bold.disabled()">
+ *       <mat-icon>format_bold</mat-icon>
+ *     </button>
+ *
+ * Behaviour only, and ARIA only where the host's widget has not spoken:
+ * - `aria-pressed` for a toggle, and `aria-disabled` when it cannot run —
+ *   both off with `[emailActionAria]="false"` for a widget that writes its own
+ *   (a Material button toggle);
+ * - never the native `disabled`, a class or a style: how disabled *looks* is
+ *   the host's, bound from `disabled()` as above. A control that is only
+ *   `aria-disabled` stays reachable by keyboard, which is what a toolbar wants;
+ * - a click on a disabled trigger runs nothing.
+ *
+ * After running, the caret goes back to the editor the action ran on — a
+ * no-op for a pointer press under `emailKeepFocus`, the way back for a key
+ * press in a toolbar. `[emailActionFocus]="false"` leaves focus on the
+ * control, as the ARIA toolbar pattern has it. A host's own action (a link
+ * dialog, a picker) never has focus taken from what it opened.
+ */
+declare class ActionTrigger {
+    /** The action to trigger — `actions.get(id)`. `undefined` (no editor yet,
+        or a kit without it) is a trigger with nothing to do: disabled. */
+    readonly action: _angular_core.InputSignal<BoundAction | undefined>;
+    /** Whether this directive writes `aria-pressed` and `aria-disabled`. */
+    readonly aria: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the caret returns to the editor after the action ran. */
+    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** On at the selection. */
+    readonly pressed: _angular_core.Signal<boolean>;
+    /** Cannot run right now — or has no action at all. */
+    readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly ariaPressed: _angular_core.Signal<boolean | null>;
+    protected readonly ariaDisabled: _angular_core.Signal<true | null>;
+    /** Runs the action, as a click does. False when it did not apply. */
+    run(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ActionTrigger, "[emailAction]", ["emailAction"], { "action": { "alias": "emailAction"; "required": true; "isSignal": true; }; "aria": { "alias": "emailActionAria"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "emailActionFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ActionTrigger, editorState, injectActions };
+export type { BoundAction, EditorActions, HostAction };

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

@@ -0,0 +1,234 @@
+import * as _h_k_dev_angular_email_editor_address from '@h-k-dev/angular-email-editor/address';
+import { Mailbox } from '@h-k-dev/angular-email-editor/address';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+/**
+ * The chip's template slot. A host that wants its own remove control — a
+ * Material icon button, a text link, a different glyph — hands the chip a
+ * template, and the chip renders it in the box at its end where the default
+ * button sits. The template gets everything the default button uses, so it
+ * can be just as accessible.
+ *
+ *     <div email-address-input [formField]="envelope.to">
+ *       <button
+ *         *emailAddressChipRemove="let remove = remove; let label = label; let disabled = disabled"
+ *         type="button"
+ *         [attr.aria-label]="label"
+ *         [disabled]="disabled"
+ *         (click)="remove()"
+ *       >
+ *         <mat-icon inline>close</mat-icon>
+ *       </button>
+ *     </div>
+ *
+ * On an address input it applies to every chip the input renders; on a chip
+ * of the host's own it applies to that chip.
+ */
+/** What the remove template is given. */
+interface AddressChipRemoveContext {
+    /** The mailbox in header form, as the chip holds it. */
+    readonly $implicit: string;
+    readonly mailbox: Mailbox;
+    /** Whether the address is well-formed. */
+    readonly valid: boolean;
+    /** Whether the address is a placeholder a template fills in later. */
+    readonly pending: boolean;
+    /** The remove control is out of play — the chip is `aria-disabled`. */
+    readonly disabled: boolean;
+    /** Whether the control belongs in the tab order. False in a list that
+        reaches its chips with the arrow keys instead; give it tabindex -1. */
+    readonly tabbable: boolean;
+    /** The control's accessible name — "Remove ada@example.com". */
+    readonly label: string;
+    /** Asks the host to drop the address; does nothing while disabled. */
+    readonly remove: () => void;
+}
+/**
+ * The chip's remove 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 button, in its `trailing` box. Not rendered at all when the chip
+ * is not `removable`.
+ */
+declare class AddressChipRemove {
+    readonly template: TemplateRef<AddressChipRemoveContext>;
+    static ngTemplateContextGuard(_directive: AddressChipRemove, context: unknown): context is AddressChipRemoveContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressChipRemove, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AddressChipRemove, "ng-template[emailAddressChipRemove]", never, {}, {}, never, never, true, never>;
+}
+
+/** The drag data type that carries a chip's address between address
+    inputs — one entry, in header form, exactly as the list holds it. It is
+    the only thing a chip's drag carries: no plain text, so no text field,
+    editor or page drop zone can take it — a chip lands in an address input
+    or nowhere. */
+declare const ADDRESS_DRAG_TYPE = "application/x-email-address";
+/**
+ * One address as a chip, the way Gmail draws it: the display name when the
+ * mailbox has one, the address otherwise, and the whole header form in the
+ * title. An address that is not one is flagged, not refused — the user
+ * sees the typo, the host decides what to do about it.
+ *
+ * **Parts are `data-slot`s** — `name`, `note`, `trailing`, `remove` — and
+ * that is how it is styled from outside: theme it through the `--email-*` tokens, and reach
+ * a part for a structural override with two attributes
+ * (`[email-address-chip] [data-slot='name'][data-slot]`).
+ *
+ * **State on the host.** `data-invalid` marks a malformed address (a list
+ * item may not carry `aria-invalid`; the flag is spoken through the `note`
+ * slot instead). `data-pending` marks a placeholder a template fills in
+ * later (`{{contact.email}}`) — no mistake, so never flagged as one; the
+ * note says what it is. `aria-disabled` takes the remove button out of play, and
+ * `aria-current` marks the chip a list's keys act on; each is an input under
+ * its ARIA name, reflected back, and a styling hook too.
+ *
+ * **The remove control is a template slot.** The chip draws its own ×
+ * button by default; an `ng-template[emailAddressChipRemove]` in the chip's
+ * content — or handed down as `removeTemplate` by the address input —
+ * replaces it, rendered in the `trailing` box with the address, the
+ * accessible name, the disabled state and a `remove()` to call.
+ *
+ * **Hold to copy.** A press held on the chip for the length of a phone's
+ * touch-and-hold — 500ms, `holdDelay` — copies the address, in header form,
+ * to the clipboard, mouse or touch alike; a release or a drag before that
+ * does not, and the browser's own context menu stays away. The chip shows
+ * and says "Copied" for a moment (`data-copied`, a live `status` slot) and
+ * emits `copied`. A list that copies the chip itself — the address input
+ * on Ctrl+C or Cmd+C — shows the same through `showCopied()`.
+ *
+ * **Drag, when asked.** Marked `draggable`, the chip can be dragged — by a
+ * mouse or a pen; a touch keeps the press for the hold, so a phone's
+ * long-press never lifts the chip instead of copying it. The drag carries
+ * the header form as `ADDRESS_DRAG_TYPE` and nothing else — no text for
+ * another field to take — allows copy and move, and cancels a hold in progress: the browser starts a drag only
+ * once the press has moved, so the two gestures never both happen. A drag
+ * from the remove control is no drag. What travels under the pointer is
+ * the chip as a pill, whole — a copy with room around it, so no engine
+ * clips its edge or a ring it wears. `data-dragging` marks the chip while
+ * it is in flight. Where the drag lands, and whether the chip leaves its
+ * list, is the list's business — the address input does both.
+ *
+ * **It asks, it does not do.** The chip holds no list: `removed` is a
+ * request the host answers by dropping the address. The address input
+ * renders these for its value; a host can render them on its own for a
+ * read-only header (a sent copy, a preview).
+ *
+ * Meant for an `<li>`. No Material, no icon font, no headless library.
+ */
+declare class AddressChip {
+    #private;
+    /** The mailbox in header form: `Ada <ada@example.com>` or `ada@example.com`. */
+    readonly address: _angular_core.InputSignal<string>;
+    /** Set false for a read-only list: the chip stays, the remove button goes. */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Draw the address as text in a line, not as a chip: no surface, no
+        room after the address, and the remove control out of the flow and out
+        of sight — still focusable, so the keyboard reaches it and a list can
+        turn back into chips when it does. The address input sets it while it
+        is not focused. Reflected as `data-inline`. */
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The list's highlight is on this chip: the one the arrow keys reached,
+        or a click picked, while the caret stays in the list's input. An input
+        under its ARIA name, like `aria-disabled`, reflected back as
+        `aria-current="true"` — the list names the same chip in its input's
+        `aria-activedescendant` — and drawn as a focus ring. */
+    readonly ariaCurrent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the remove button is in the tab order. A list that reaches
+        its chips with the arrow keys sets false: Tab goes straight to its
+        input, and the button stays clickable and focusable by script. */
+    readonly removeTabbable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Prefix for the remove button's accessible name — "Remove ada@example.com". */
+    readonly removeLabel: _angular_core.InputSignal<string>;
+    /** What the flag on a malformed address says, for the title and for
+        assistive tech. */
+    readonly invalidLabel: _angular_core.InputSignal<string>;
+    /** What the note on a placeholder says, for the title and for assistive
+        tech. */
+    readonly pendingLabel: _angular_core.InputSignal<string>;
+    /** The remove button is out of play — e.g. while the message sends. */
+    readonly ariaDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The remove button was pressed. The host drops the address; the chip
+        goes when the host's list no longer has it. */
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    /** How long a press must be held to copy the address, in milliseconds:
+        the length of a phone's touch-and-hold, 500ms, so the gesture is the
+        one a thumb already knows. 0 turns the hold off. */
+    readonly holdDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** What the chip says, for a moment, once a hold has copied the address
+        — "Copied", followed by the address. */
+    readonly copiedLabel: _angular_core.InputSignal<string>;
+    /** A hold copied the address to the clipboard, in header form. */
+    readonly copied: _angular_core.OutputEmitterRef<string>;
+    /** The address was just copied: shown for a moment, and said. Reflected
+        as `data-copied`. */
+    protected readonly justCopied: _angular_core.WritableSignal<boolean>;
+    /** What the `status` slot says for a moment — a copy, or a list's
+        `announce()`. */
+    protected readonly status: _angular_core.WritableSignal<string>;
+    /** The chip may be dragged — to another address input, or as text into
+        any field. Off by default: a chip on its own has no list to leave; the
+        address input turns it on for an editable list. Reflected as
+        `draggable` for a mouse or pen, never for a touch. */
+    readonly draggable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The last press was a touch: no drag, so the press stays the hold's. */
+    protected readonly touching: _angular_core.WritableSignal<boolean>;
+    /** The chip is being dragged. Reflected as `data-dragging`. */
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** A press begins a hold — a primary pointer, mouse or touch alike, on
+        the chip itself and not its remove control. */
+    protected onPointerdown(event: PointerEvent): void;
+    /** A hold that moves is a drag or a scroll, not a hold. */
+    protected onPointermove(event: PointerEvent): void;
+    /** Released, cancelled or gone before the time: no copy. */
+    protected cancelHold(): void;
+    /** A drag begins: the address goes along in header form, as the
+        library's own type only, and a hold in progress is over.
+        Not from the remove control. */
+    protected onDragstart(event: DragEvent): void;
+    /** The hold is the chip's, not the browser's: no context menu on it, on
+        a phone or under a right button. */
+    protected onContextmenu(event: Event): void;
+    /** Copies the address, in header form, to the clipboard — what a hold
+        does, and what a host's own control may ask for — and shows and says
+        so. The async API first; when it refuses (an unfocused document, a
+        context without it), the old copy command on a selection made for the
+        purpose. Resolves to whether the copy went. */
+    copy(): Promise<boolean>;
+    /** Shows and says, for a moment, that the address is on the clipboard,
+        and emits `copied` — what a copy does once the clipboard has it. For a
+        list that put it there itself: the address input's Ctrl+C, which
+        writes the clipboard in the copy event, synchronously. */
+    showCopied(): void;
+    /** Says something about the chip through its `status` slot, for a
+        moment — what a copy says, and what a list says of a chip it just
+        received ("Moved to Cc: …"). */
+    announce(message: string): void;
+    /** A remove template handed down by a list that renders the chip — the
+        address input passes its own `emailAddressChipRemove` slot here. One
+        in the chip's own content wins. */
+    readonly removeTemplate: _angular_core.InputSignal<TemplateRef<AddressChipRemoveContext> | null>;
+    protected readonly removeSlot: _angular_core.Signal<AddressChipRemove | undefined>;
+    /** The template the trailing box renders, or null for the default button. */
+    protected readonly removeOutlet: _angular_core.Signal<TemplateRef<AddressChipRemoveContext> | null>;
+    protected readonly mailbox: _angular_core.Signal<_h_k_dev_angular_email_editor_address.Mailbox>;
+    /** Whether the address part is well-formed. Public so a list can count. */
+    readonly valid: _angular_core.Signal<boolean>;
+    /** Whether the address is a placeholder a template fills in later —
+        neither valid nor invalid yet. */
+    readonly pending: _angular_core.Signal<boolean>;
+    /** The remove control's accessible name — "Remove ada@example.com". */
+    protected readonly removeName: _angular_core.Signal<string>;
+    protected readonly removeContext: _angular_core.Signal<AddressChipRemoveContext>;
+    /** Asks to be removed, unless the control is out of play. One function
+        for the chip's life, so a template holding it never sees it change. */
+    protected readonly remove: () => void;
+    /** The note the chip carries, if any — said, and shown in the title. */
+    protected readonly note: _angular_core.Signal<string | null>;
+    protected readonly title: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddressChip, "[email-address-chip]", never, { "address": { "alias": "address"; "required": true; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "ariaCurrent": { "alias": "aria-current"; "required": false; "isSignal": true; }; "removeTabbable": { "alias": "removeTabbable"; "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; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; "isSignal": true; }; "holdDelay": { "alias": "holdDelay"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "removeTemplate": { "alias": "removeTemplate"; "required": false; "isSignal": true; }; }, { "removed": "removed"; "copied": "copied"; }, ["removeSlot"], never, true, never>;
+}
+
+export { ADDRESS_DRAG_TYPE, AddressChip, AddressChipRemove };
+export type { AddressChipRemoveContext };