@firestitch/report 18.8.0 → 18.9.0

package/esm2022/app/reports/components/component-text/value-embed.plugin.mjs

@@ -0,0 +1,484 @@
+import { Plugin } from '@firestitch/html-editor';
+import { VALUE_TOKEN_PATTERN, valueText, valueToken } from '../../text';
+// How a value chip is marked in the editor. The names follow the embeds of
+// @firestitch/markdown-editor. Attributes rather than a class: the report keeps
+// Froala on inline styles (useClasses: false), and a chip never reaches storage
+// anyway — it turns back into its {{value.key}} token on the way out.
+const TYPE_ATTRIBUTE = 'data-embed-type';
+const KEY_ATTRIBUTE = 'data-embed-key';
+const MISSING_ATTRIBUTE = 'data-embed-missing';
+const CHIP_SELECTOR = `[${KEY_ATTRIBUTE}]`;
+const VALUE_TYPE = 'value';
+// The page a copy came from, on the clipboard beside its text: values belong
+// to their page, so a value pasted onto another one doesn't come with it.
+const SCOPE_TYPE = 'application/x-fs-report-value-scope';
+// What Froala must keep on a chip when it cleans html it is handed.
+export const VALUE_EMBED_ATTRIBUTES = [TYPE_ATTRIBUTE, KEY_ATTRIBUTE, MISSING_ATTRIBUTE, 'contenteditable'];
+// A brief ring around the chips an edit was stopped at.
+const FLASH = [{ boxShadow: '0 0 0 2px #e15759' }, { boxShadow: '0 0 0 2px transparent' }];
+const FLASH_MS = 700;
+// Commands that would build what the server rewrites (ReportTextHtml): a table
+// is kept only between paragraphs, and a cell holds words and values only.
+const TABLE_INSERT_COMMANDS = ['insertTable', 'tableInsert'];
+const NO_TABLE_INSIDE = 'li, td, th';
+const CELL_COMMANDS = ['formatUL', 'formatOL', 'paragraphFormat'];
+const CELL = 'td, th';
+// Undo and redo restore a step; they remove nothing of their own.
+const HISTORY_COMMANDS = ['undo', 'redo'];
+// Keys that, pressed alone, edit nothing.
+const MODIFIER_KEYS = ['Shift', 'Control', 'Alt', 'AltGraph', 'Meta'];
+// The cells of a table selected as cells (Froala's own marking).
+const SELECTED_CELL = '.fr-selected-cell';
+// Live values inside a text block's editor.
+//
+// Stored html carries a value as a {{value.key}} token. While editing, each
+// token is a chip: one character to the cursor, labeled with the value, and
+// reporting a click. Froala's html.get hands back tokens again, so the draft
+// and the saved html never hold a chip.
+//
+// A chip can't be deleted by editing: Backspace or Delete beside it, and any
+// deleting, typing over, cutting, pasting over or dragging of a selection that
+// holds one, is stopped and reported. It is taken out on purpose by selecting
+// it and pressing Delete, then taking the stopped selection's
+// removeSelection(); a value that was deleted leaves through removeKey().
+//
+// A table is the exception: deleting a row, a column or the table, or
+// emptying several selected cells, goes through with the chips in it, and is
+// reported as removed() when it took a value's last chip, with the undo that
+// brings them back.
+export class ValueEmbedPlugin extends Plugin {
+    // The editor this plugin serves; null until it is built, and after it is gone.
+    _editor = null;
+    // Set while a deliberate removal runs, so the guards let it through.
+    _removing = false;
+    // Listeners on the editable element, captured so each runs before Froala's
+    // own handler for the same event.
+    _domListeners = [];
+    // The page the paste under way was copied on ('' when not from a block).
+    _pasteScope = '';
+    // How many chips each key had as the command under way started; null for
+    // one that removes nothing of its own (undo, redo).
+    _before = null;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    initialize() {
+        if (!this.config.host().contains(this.editor.el)) {
+            return;
+        }
+        const editor = this.editor;
+        const el = editor.el;
+        this._editor = editor;
+        editor.events.on('html.set', () => this._toChips());
+        editor.events.on('paste.after', () => this._toChips(true));
+        this._watchCommands(editor);
+        editor.events.on('html.get', (html) => this._toTokens(html));
+        // First in Froala's chain, so its own Backspace handling never runs on a
+        // stopped key.
+        editor.events.on('keydown', (event) => this._onKeydown(event), true);
+        editor.events.on('paste.before', (event) => {
+            this._pasteScope = event?.clipboardData?.getData(SCOPE_TYPE) ?? '';
+            return this._guardSelection(event);
+        });
+        // A press on a chip opens its popover; Froala's floating toolbar, which
+        // pops up on any press in the text and sits above every overlay, stays
+        // away for it.
+        editor.events.on('toolbar.show', (event) => (this._onChip(event) ? false : undefined), true);
+        // Only while it is still this editor: reopening a block builds the next
+        // one before the last is torn down.
+        editor.events.on('destroy', () => {
+            if (this._editor === editor) {
+                this.destroy();
+            }
+        });
+        this._domListeners = [
+            ['beforeinput', (event) => this._onBeforeInput(event)],
+            ['cut', (event) => this._guardSelection(event)],
+            ['dragstart', (event) => this._guardSelection(event)],
+            ['copy', (event) => this._onCopy(event)],
+            ['click', (event) => this._onClick(event)],
+        ];
+        this._domListeners.forEach(([name, listener]) => el.addEventListener(name, listener, true));
+        this._toChips();
+    }
+    destroy() {
+        const el = this._editor?.el;
+        this._domListeners.forEach(([name, listener]) => el?.removeEventListener(name, listener, true));
+        this._domListeners = [];
+        this._editor = null;
+    }
+    // Relabel every chip: the values arrived or changed, or names were toggled.
+    refresh() {
+        this._chips().forEach((chip) => this._label(chip));
+    }
+    // Put Froala's floating toolbar and a table's popup away, when either is
+    // already up as a chip's popover opens: they sit above every overlay.
+    hideToolbar() {
+        this._editor?.toolbar.hide();
+        this._editor?.popups.hide('table.edit');
+    }
+    // The editor's own undo of the last step: what puts back the chips an edit
+    // took out.
+    undo() {
+        this._editor?.commands.undo();
+    }
+    // Take a value out of the text, wherever it appears — it was deleted.
+    removeKey(key) {
+        this._chips()
+            .filter((chip) => chip.getAttribute(KEY_ATTRIBUTE) === key)
+            .forEach((chip) => this.remove(chip));
+    }
+    // Take one chip out of the text.
+    remove(chip) {
+        if (!this._editor?.el.contains(chip)) {
+            return;
+        }
+        // The cursor goes back where the chip was — whatever asked for the
+        // removal (a dialog, a popover) took the focus, and without it an Undo
+        // straight after would never reach the editor.
+        const caret = document.createRange();
+        caret.setStartBefore(chip);
+        caret.collapse(true);
+        this._editor.undo.saveStep();
+        chip.remove();
+        this._editor.el.focus();
+        const selection = this._selection();
+        selection.removeAllRanges();
+        selection.addRange(caret);
+        this._changed();
+    }
+    _chips() {
+        return this._editor
+            ? Array.from(this._editor.el.querySelectorAll(CHIP_SELECTOR))
+            : [];
+    }
+    // How many chips each key has in the block.
+    _chipCounts() {
+        const counts = new Map();
+        this._chips().forEach((chip) => {
+            const key = chip.getAttribute(KEY_ATTRIBUTE);
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        });
+        return counts;
+    }
+    // Tell the host when an edit took the last chip of some key out of the
+    // block, given the counts from before it.
+    _reportRemoved(before) {
+        if (!before || !this._editor) {
+            return;
+        }
+        const after = this._chipCounts();
+        if ([...before.keys()].some((key) => !after.has(key))) {
+            this.config.removed({
+                before: [...before.keys()],
+                after: [...after.keys()],
+                undo: () => this.undo(),
+            });
+        }
+    }
+    // A toolbar command sees tokens, not chips: Clear formatting unwraps every
+    // span, a chip included, which would leave a typed number behind. Around a
+    // token it formats plain text, and the chip comes back inside whatever
+    // formatting the token was given.
+    _watchCommands(editor) {
+        editor.events.on('commands.before', (command) => this._onCommandBefore(command));
+        editor.events.on('commands.after', () => {
+            this._toChips();
+            this._reportRemoved(this._before);
+            this._before = null;
+        });
+        // Undo and redo restore a step as Froala saved it: the one before a
+        // command holds tokens, as the command saw them. Neither fires
+        // commands.after: Froala's commands.undo() — Ctrl+Z, and undo() here —
+        // runs the undo directly.
+        editor.events.on('commands.undo', () => this._toChips());
+        editor.events.on('commands.redo', () => this._toChips());
+    }
+    // Every command starts a new edit. One that would build what the server
+    // rewrites is refused (returning false cancels it); any other runs on
+    // tokens, its chip counts kept to see what it removed.
+    _onCommandBefore(command) {
+        this.config.changed();
+        if (TABLE_INSERT_COMMANDS.includes(command) && this._caretIn(NO_TABLE_INSIDE)) {
+            this.config.refused('A table goes between paragraphs, never inside a list or another table.');
+            return false;
+        }
+        if (CELL_COMMANDS.includes(command) && this._caretIn(CELL)) {
+            this.config.refused('A table cell holds words and values; a list or a heading goes outside the table.');
+            return false;
+        }
+        this._before = HISTORY_COMMANDS.includes(command) ? null : this._chipCounts();
+        this._toTokenText();
+    }
+    // Whether the caret sits inside an element of this editor that `selector`
+    // matches.
+    _caretIn(selector) {
+        const container = this._editor.selection.element()?.closest?.(selector) ?? null;
+        return !!container && this._editor.el.contains(container);
+    }
+    // Turn every {{value.key}} token in the editor's text into a chip. For a
+    // paste, a token only stays when it was copied on this page and the page has
+    // the value; otherwise it goes, and just the text around it is pasted.
+    _toChips(pasted = false) {
+        const el = this._editor?.el;
+        if (!el) {
+            return;
+        }
+        const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+        const texts = [];
+        while (walker.nextNode()) {
+            const text = walker.currentNode;
+            if (text.data.includes('{{') && !text.parentElement?.closest(CHIP_SELECTOR)) {
+                texts.push(text);
+            }
+        }
+        texts.forEach((text) => this._splitText(text, pasted));
+    }
+    _keepsPasted(key) {
+        return this._pasteScope === this.config.scope() && !!this.config.values()[key];
+    }
+    _splitText(text, pasted) {
+        const matches = Array.from(text.data.matchAll(VALUE_TOKEN_PATTERN));
+        if (!matches.length) {
+            return;
+        }
+        // Only non-empty text around the chips, so a selection counted in child
+        // nodes keeps its place.
+        const fragment = document.createDocumentFragment();
+        const appendText = (value) => {
+            if (value) {
+                fragment.append(value);
+            }
+        };
+        let consumed = 0;
+        matches.forEach((match) => {
+            const key = match[1].toLowerCase();
+            appendText(text.data.slice(consumed, match.index));
+            if (!pasted || this._keepsPasted(key)) {
+                fragment.append(this._createChip(key));
+            }
+            consumed = match.index + match[0].length;
+        });
+        appendText(text.data.slice(consumed));
+        text.replaceWith(fragment);
+    }
+    // Every chip in the editor back to its token, as text.
+    _toTokenText() {
+        this._chips().forEach((chip) => chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE))));
+    }
+    _createChip(key) {
+        const chip = document.createElement('span');
+        chip.setAttribute(TYPE_ATTRIBUTE, VALUE_TYPE);
+        chip.setAttribute(KEY_ATTRIBUTE, key);
+        chip.setAttribute('contenteditable', 'false');
+        this._label(chip);
+        return chip;
+    }
+    // A chip reads as the value does in the viewed block — its number, the
+    // ellipsis while that loads, else the em dash — so opening the editor moves
+    // no word; or as its name, when names are toggled on. A key with no value on
+    // the page reads as the key itself, marked missing.
+    _label(chip) {
+        const key = chip.getAttribute(KEY_ATTRIBUTE);
+        const value = this.config.values()[key];
+        chip.textContent = !value
+            ? key
+            : this.config.showNames() ? value.name : valueText(value);
+        chip.title = value?.name ?? key;
+        chip.toggleAttribute(MISSING_ATTRIBUTE, !value);
+    }
+    // The html Froala hands out, with every chip back to its token.
+    _toTokens(html) {
+        if (!html.includes(KEY_ATTRIBUTE)) {
+            return html;
+        }
+        const template = document.createElement('template');
+        template.innerHTML = html;
+        template.content.querySelectorAll(CHIP_SELECTOR).forEach((chip) => {
+            chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE)));
+        });
+        return template.innerHTML;
+    }
+    _onKeydown(event) {
+        // Any key but a lone modifier starts a new edit.
+        if (!MODIFIER_KEYS.includes(event.key)) {
+            this.config.changed();
+        }
+        const deleting = event.key === 'Backspace' || event.key === 'Delete';
+        // Deleting across several selected cells goes through, values and all:
+        // Froala saves an undo step and empties the cells, and what that took is
+        // reported once they are empty.
+        if (deleting && this._editor.el.querySelectorAll(SELECTED_CELL).length > 1) {
+            const before = this._chipCounts();
+            setTimeout(() => this._reportRemoved(before));
+            return undefined;
+        }
+        const range = this._range();
+        if (!range) {
+            return;
+        }
+        if (range.collapsed) {
+            if (!deleting) {
+                return;
+            }
+            const chip = this._adjacentChip(event.key === 'Backspace', this._granularity(event));
+            return chip ? this._block(event, [chip], null) : undefined;
+        }
+        // A selection is replaced by a deleting key, Enter, a typed character or
+        // a cut.
+        const typing = event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+        const cutting = (event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'x';
+        if (!deleting && !typing && !cutting && event.key !== 'Enter') {
+            return;
+        }
+        const chips = this._chipsIn(range);
+        return chips.length ? this._block(event, chips, range) : undefined;
+    }
+    // The same rule for edits that arrive without a key Froala sees: a phone
+    // keyboard, an input method, a spell-check replacement.
+    _onBeforeInput(event) {
+        const range = this._range();
+        if (this._removing || !range) {
+            return;
+        }
+        if (range.collapsed) {
+            const backward = event.inputType.endsWith('Backward');
+            if (event.inputType.startsWith('delete')) {
+                const chip = this._adjacentChip(backward, event.inputType.includes('Word') ? 'word' : 'character');
+                if (chip) {
+                    this._block(event, [chip], null);
+                }
+            }
+            return;
+        }
+        const chips = this._chipsIn(range);
+        if (chips.length) {
+            this._block(event, chips, range);
+        }
+    }
+    // Cut, drag and paste-over: stopped when the selection holds a value.
+    _guardSelection(event) {
+        const range = this._range();
+        if (this._removing || !range || range.collapsed) {
+            return;
+        }
+        const chips = this._chipsIn(range);
+        return chips.length ? this._block(event, chips, range) : undefined;
+    }
+    // Copying a value copies its token, and the page it was copied on, so
+    // pasting it back on this page — in this block or another — makes it a chip
+    // again.
+    _onCopy(event) {
+        const range = this._range();
+        if (!range || range.collapsed || !this._chipsIn(range).length) {
+            return;
+        }
+        const holder = document.createElement('div');
+        holder.append(range.cloneContents());
+        holder.querySelectorAll(CHIP_SELECTOR).forEach((chip) => {
+            chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE)));
+        });
+        event.clipboardData.setData('text/plain', this._plainText(holder));
+        event.clipboardData.setData('text/html', holder.innerHTML);
+        event.clipboardData.setData(SCOPE_TYPE, this.config.scope());
+        event.preventDefault();
+    }
+    // What copied html reads as in plain text: a paragraph on its own lines, a
+    // table's cells tab-separated and its rows on lines of their own. That is
+    // the browser's innerText, which only text laid out on the page has — so
+    // the holder is put offscreen (not hidden: hidden text has none) while it is
+    // read.
+    _plainText(holder) {
+        holder.style.cssText = 'position: fixed; left: -10000px; top: 0';
+        document.body.append(holder);
+        const text = holder.innerText;
+        holder.remove();
+        return text;
+    }
+    _onClick(event) {
+        const chip = event.target?.closest?.(CHIP_SELECTOR);
+        if (!chip || !this._editor?.el.contains(chip)) {
+            return;
+        }
+        event.preventDefault();
+        // A press in a table cell can open the table's popup on mouseup, just
+        // before this click; a chip in a cell shows only its own popover.
+        this._editor.popups.hide('table.edit');
+        this.config.click(chip.getAttribute(KEY_ATTRIBUTE), chip);
+    }
+    _onChip(event) {
+        return !!event?.target?.closest?.(CHIP_SELECTOR);
+    }
+    _block(event, chips, range) {
+        event.preventDefault();
+        event.stopPropagation();
+        chips.forEach((chip) => chip.animate(FLASH, FLASH_MS));
+        this.config.blocked({
+            count: chips.length,
+            ...(range ? { removeSelection: () => this._removeRange(range) } : {}),
+        });
+        return false;
+    }
+    _removeRange(range) {
+        if (!this._editor) {
+            return;
+        }
+        const selection = this._selection();
+        this._editor.el.focus();
+        selection.removeAllRanges();
+        selection.addRange(range);
+        this._editor.undo.saveStep();
+        this._removing = true;
+        // The browser's own delete, so two paragraphs a selection spans join the
+        // way they would for a plain Delete.
+        document.execCommand('delete');
+        this._removing = false;
+        this._changed();
+    }
+    // An edit made here rather than typed: record it for undo, and tell
+    // html-editor so the draft follows.
+    _changed() {
+        this._editor.undo.saveStep();
+        this._editor.events.trigger('contentChanged');
+    }
+    _selection() {
+        return this._editor.el.ownerDocument.getSelection();
+    }
+    // The selection, when it is inside this editor.
+    _range() {
+        const selection = this._editor ? this._selection() : null;
+        if (!selection?.rangeCount) {
+            return null;
+        }
+        const range = selection.getRangeAt(0);
+        return this._editor.el.contains(range.commonAncestorContainer) ? range : null;
+    }
+    _chipsIn(range) {
+        return this._chips().filter((chip) => range.intersectsNode(chip));
+    }
+    // The chip a collapsed cursor would delete into: stretch the selection by
+    // what the key deletes, see what it covers, and put it back. Letting the
+    // browser stretch it handles every shape the html takes — a chip inside a
+    // bold span, at a line's end, beside an empty text node.
+    _adjacentChip(backward, granularity) {
+        const selection = this._selection();
+        const range = selection.getRangeAt(0).cloneRange();
+        selection.modify('extend', backward ? 'backward' : 'forward', granularity);
+        const chip = selection.rangeCount
+            ? this._chipsIn(selection.getRangeAt(0))[0] ?? null
+            : null;
+        selection.removeAllRanges();
+        selection.addRange(range);
+        return chip;
+    }
+    // How far a deleting key reaches: a word with Ctrl/Alt, to the line's start
+    // with Cmd on a Mac, one character otherwise.
+    _granularity(event) {
+        if (event.metaKey) {
+            return 'lineboundary';
+        }
+        return event.ctrlKey || event.altKey ? 'word' : 'character';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value-embed.plugin.js","sourceRoot":"","sources":["../../../../../../src/app/reports/components/component-text/value-embed.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Plugin, PluginConfig } from '@firestitch/html-editor';\n\nimport { TextValue, VALUE_TOKEN_PATTERN, valueText, valueToken } from '../../text';\n\n\n// How a value chip is marked in the editor. The names follow the embeds of\n// @firestitch/markdown-editor. Attributes rather than a class: the report keeps\n// Froala on inline styles (useClasses: false), and a chip never reaches storage\n// anyway — it turns back into its {{value.key}} token on the way out.\nconst TYPE_ATTRIBUTE = 'data-embed-type';\nconst KEY_ATTRIBUTE = 'data-embed-key';\nconst MISSING_ATTRIBUTE = 'data-embed-missing';\nconst CHIP_SELECTOR = `[${KEY_ATTRIBUTE}]`;\nconst VALUE_TYPE = 'value';\n\n// The page a copy came from, on the clipboard beside its text: values belong\n// to their page, so a value pasted onto another one doesn't come with it.\nconst SCOPE_TYPE = 'application/x-fs-report-value-scope';\n\n// What Froala must keep on a chip when it cleans html it is handed.\nexport const VALUE_EMBED_ATTRIBUTES = [TYPE_ATTRIBUTE, KEY_ATTRIBUTE, MISSING_ATTRIBUTE, 'contenteditable'];\n\n// A brief ring around the chips an edit was stopped at.\nconst FLASH: Keyframe[] = [{ boxShadow: '0 0 0 2px #e15759' }, { boxShadow: '0 0 0 2px transparent' }];\nconst FLASH_MS = 700;\n\n// Commands that would build what the server rewrites (ReportTextHtml): a table\n// is kept only between paragraphs, and a cell holds words and values only.\nconst TABLE_INSERT_COMMANDS = ['insertTable', 'tableInsert'];\nconst NO_TABLE_INSIDE = 'li, td, th';\nconst CELL_COMMANDS = ['formatUL', 'formatOL', 'paragraphFormat'];\nconst CELL = 'td, th';\n\n// Undo and redo restore a step; they remove nothing of their own.\nconst HISTORY_COMMANDS = ['undo', 'redo'];\n\n// Keys that, pressed alone, edit nothing.\nconst MODIFIER_KEYS = ['Shift', 'Control', 'Alt', 'AltGraph', 'Meta'];\n\n// The cells of a table selected as cells (Froala's own marking).\nconst SELECTED_CELL = '.fr-selected-cell';\n\n// An edit that would have removed values, and was stopped.\nexport interface ValueEmbedBlock {\n  count: number;\n  // Present when the edit was on a selection: removes the selection, values\n  // and all — the deliberate way through.\n  removeSelection?: () => void;\n}\n\n// An edit that took the last chip of some values out of the block: deleting\n// a row, a column or a table, or emptying cells. Allowed, values and all.\nexport interface ValueEmbedRemoval {\n  // The keys the block's chips named before the edit, and after it.\n  before: string[];\n  after: string[];\n  // The editor's own undo, which brings the chips back.\n  undo: () => void;\n}\n\nexport interface ValueEmbedPluginConfig extends PluginConfig {\n  // The element the editor sits in. html-editor registers a plugin with Froala\n  // globally, so Froala hands it every editor built afterwards; it works only\n  // for the one inside this element.\n  host: () => HTMLElement;\n  // The page's values, by key. One whose number is still on its way is listed\n  // with loading: true; a key not listed is no value of the page.\n  values: () => Record<string, TextValue>;\n  // The page the block's values belong to.\n  scope: () => string;\n  // Label chips with the value's name instead of its number.\n  showNames: () => boolean;\n  click: (key: string, chip: HTMLElement) => void;\n  blocked: (block: ValueEmbedBlock) => void;\n  removed: (removal: ValueEmbedRemoval) => void;\n  // A key was pressed or a command is about to run: what was said about the\n  // last edit no longer applies.\n  changed: () => void;\n  // A command was refused, and why.\n  refused: (text: string) => void;\n}\n\n// Live values inside a text block's editor.\n//\n// Stored html carries a value as a {{value.key}} token. While editing, each\n// token is a chip: one character to the cursor, labeled with the value, and\n// reporting a click. Froala's html.get hands back tokens again, so the draft\n// and the saved html never hold a chip.\n//\n// A chip can't be deleted by editing: Backspace or Delete beside it, and any\n// deleting, typing over, cutting, pasting over or dragging of a selection that\n// holds one, is stopped and reported. It is taken out on purpose by selecting\n// it and pressing Delete, then taking the stopped selection's\n// removeSelection(); a value that was deleted leaves through removeKey().\n//\n// A table is the exception: deleting a row, a column or the table, or\n// emptying several selected cells, goes through with the chips in it, and is\n// reported as removed() when it took a value's last chip, with the undo that\n// brings them back.\nexport class ValueEmbedPlugin extends Plugin {\n\n  // The base class's config, typed for this plugin.\n  public declare config: ValueEmbedPluginConfig;\n\n  // The editor this plugin serves; null until it is built, and after it is gone.\n  private _editor: any = null;\n  // Set while a deliberate removal runs, so the guards let it through.\n  private _removing = false;\n  // Listeners on the editable element, captured so each runs before Froala's\n  // own handler for the same event.\n  private _domListeners: [string, EventListener][] = [];\n  // The page the paste under way was copied on ('' when not from a block).\n  private _pasteScope = '';\n  // How many chips each key had as the command under way started; null for\n  // one that removes nothing of its own (undo, redo).\n  private _before: Map<string, number> | null = null;\n\n  constructor(config: ValueEmbedPluginConfig) {\n    super();\n    this.config = config;\n  }\n\n  public initialize(): void {\n    if (!this.config.host().contains(this.editor.el)) {\n      return;\n    }\n\n    const editor = this.editor;\n    const el: HTMLElement = editor.el;\n    this._editor = editor;\n\n    editor.events.on('html.set', () => this._toChips());\n    editor.events.on('paste.after', () => this._toChips(true));\n    this._watchCommands(editor);\n    editor.events.on('html.get', (html: string) => this._toTokens(html));\n    // First in Froala's chain, so its own Backspace handling never runs on a\n    // stopped key.\n    editor.events.on('keydown', (event: KeyboardEvent) => this._onKeydown(event), true);\n    editor.events.on('paste.before', (event: ClipboardEvent) => {\n      this._pasteScope = event?.clipboardData?.getData(SCOPE_TYPE) ?? '';\n\n      return this._guardSelection(event);\n    });\n    // A press on a chip opens its popover; Froala's floating toolbar, which\n    // pops up on any press in the text and sits above every overlay, stays\n    // away for it.\n    editor.events.on('toolbar.show', (event?: Event) => (this._onChip(event) ? false : undefined), true);\n    // Only while it is still this editor: reopening a block builds the next\n    // one before the last is torn down.\n    editor.events.on('destroy', () => {\n      if (this._editor === editor) {\n        this.destroy();\n      }\n    });\n\n    this._domListeners = [\n      ['beforeinput', (event) => this._onBeforeInput(event as InputEvent)],\n      ['cut', (event) => this._guardSelection(event)],\n      ['dragstart', (event) => this._guardSelection(event)],\n      ['copy', (event) => this._onCopy(event as ClipboardEvent)],\n      ['click', (event) => this._onClick(event as MouseEvent)],\n    ];\n    this._domListeners.forEach(([name, listener]) => el.addEventListener(name, listener, true));\n\n    this._toChips();\n  }\n\n  public destroy(): void {\n    const el: HTMLElement | undefined = this._editor?.el;\n    this._domListeners.forEach(([name, listener]) => el?.removeEventListener(name, listener, true));\n    this._domListeners = [];\n    this._editor = null;\n  }\n\n  // Relabel every chip: the values arrived or changed, or names were toggled.\n  public refresh(): void {\n    this._chips().forEach((chip) => this._label(chip));\n  }\n\n  // Put Froala's floating toolbar and a table's popup away, when either is\n  // already up as a chip's popover opens: they sit above every overlay.\n  public hideToolbar(): void {\n    this._editor?.toolbar.hide();\n    this._editor?.popups.hide('table.edit');\n  }\n\n  // The editor's own undo of the last step: what puts back the chips an edit\n  // took out.\n  public undo(): void {\n    this._editor?.commands.undo();\n  }\n\n  // Take a value out of the text, wherever it appears — it was deleted.\n  public removeKey(key: string): void {\n    this._chips()\n      .filter((chip) => chip.getAttribute(KEY_ATTRIBUTE) === key)\n      .forEach((chip) => this.remove(chip));\n  }\n\n  // Take one chip out of the text.\n  public remove(chip: HTMLElement): void {\n    if (!this._editor?.el.contains(chip)) {\n      return;\n    }\n\n    // The cursor goes back where the chip was — whatever asked for the\n    // removal (a dialog, a popover) took the focus, and without it an Undo\n    // straight after would never reach the editor.\n    const caret = document.createRange();\n    caret.setStartBefore(chip);\n    caret.collapse(true);\n\n    this._editor.undo.saveStep();\n    chip.remove();\n    this._editor.el.focus();\n    const selection = this._selection();\n    selection.removeAllRanges();\n    selection.addRange(caret);\n    this._changed();\n  }\n\n  private _chips(): HTMLElement[] {\n    return this._editor\n      ? Array.from(this._editor.el.querySelectorAll(CHIP_SELECTOR))\n      : [];\n  }\n\n  // How many chips each key has in the block.\n  private _chipCounts(): Map<string, number> {\n    const counts = new Map<string, number>();\n    this._chips().forEach((chip) => {\n      const key = chip.getAttribute(KEY_ATTRIBUTE);\n      counts.set(key, (counts.get(key) ?? 0) + 1);\n    });\n\n    return counts;\n  }\n\n  // Tell the host when an edit took the last chip of some key out of the\n  // block, given the counts from before it.\n  private _reportRemoved(before: Map<string, number> | null): void {\n    if (!before || !this._editor) {\n      return;\n    }\n\n    const after = this._chipCounts();\n    if ([...before.keys()].some((key) => !after.has(key))) {\n      this.config.removed({\n        before: [...before.keys()],\n        after: [...after.keys()],\n        undo: () => this.undo(),\n      });\n    }\n  }\n\n  // A toolbar command sees tokens, not chips: Clear formatting unwraps every\n  // span, a chip included, which would leave a typed number behind. Around a\n  // token it formats plain text, and the chip comes back inside whatever\n  // formatting the token was given.\n  private _watchCommands(editor: any): void {\n    editor.events.on('commands.before', (command: string) => this._onCommandBefore(command));\n    editor.events.on('commands.after', () => {\n      this._toChips();\n      this._reportRemoved(this._before);\n      this._before = null;\n    });\n    // Undo and redo restore a step as Froala saved it: the one before a\n    // command holds tokens, as the command saw them. Neither fires\n    // commands.after: Froala's commands.undo() — Ctrl+Z, and undo() here —\n    // runs the undo directly.\n    editor.events.on('commands.undo', () => this._toChips());\n    editor.events.on('commands.redo', () => this._toChips());\n  }\n\n  // Every command starts a new edit. One that would build what the server\n  // rewrites is refused (returning false cancels it); any other runs on\n  // tokens, its chip counts kept to see what it removed.\n  private _onCommandBefore(command: string): false | void {\n    this.config.changed();\n\n    if (TABLE_INSERT_COMMANDS.includes(command) && this._caretIn(NO_TABLE_INSIDE)) {\n      this.config.refused('A table goes between paragraphs, never inside a list or another table.');\n\n      return false;\n    }\n\n    if (CELL_COMMANDS.includes(command) && this._caretIn(CELL)) {\n      this.config.refused('A table cell holds words and values; a list or a heading goes outside the table.');\n\n      return false;\n    }\n\n    this._before = HISTORY_COMMANDS.includes(command) ? null : this._chipCounts();\n    this._toTokenText();\n  }\n\n  // Whether the caret sits inside an element of this editor that `selector`\n  // matches.\n  private _caretIn(selector: string): boolean {\n    const container: Element | null = this._editor.selection.element()?.closest?.(selector) ?? null;\n\n    return !!container && this._editor.el.contains(container);\n  }\n\n  // Turn every {{value.key}} token in the editor's text into a chip. For a\n  // paste, a token only stays when it was copied on this page and the page has\n  // the value; otherwise it goes, and just the text around it is pasted.\n  private _toChips(pasted = false): void {\n    const el: HTMLElement | undefined = this._editor?.el;\n    if (!el) {\n      return;\n    }\n\n    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);\n    const texts: Text[] = [];\n    while (walker.nextNode()) {\n      const text = walker.currentNode as Text;\n      if (text.data.includes('{{') && !text.parentElement?.closest(CHIP_SELECTOR)) {\n        texts.push(text);\n      }\n    }\n\n    texts.forEach((text) => this._splitText(text, pasted));\n  }\n\n  private _keepsPasted(key: string): boolean {\n    return this._pasteScope === this.config.scope() && !!this.config.values()[key];\n  }\n\n  private _splitText(text: Text, pasted: boolean): void {\n    const matches = Array.from(text.data.matchAll(VALUE_TOKEN_PATTERN));\n    if (!matches.length) {\n      return;\n    }\n\n    // Only non-empty text around the chips, so a selection counted in child\n    // nodes keeps its place.\n    const fragment = document.createDocumentFragment();\n    const appendText = (value: string) => {\n      if (value) {\n        fragment.append(value);\n      }\n    };\n    let consumed = 0;\n    matches.forEach((match) => {\n      const key = match[1].toLowerCase();\n      appendText(text.data.slice(consumed, match.index));\n      if (!pasted || this._keepsPasted(key)) {\n        fragment.append(this._createChip(key));\n      }\n      consumed = match.index + match[0].length;\n    });\n    appendText(text.data.slice(consumed));\n\n    text.replaceWith(fragment);\n  }\n\n  // Every chip in the editor back to its token, as text.\n  private _toTokenText(): void {\n    this._chips().forEach((chip) => chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE))));\n  }\n\n  private _createChip(key: string): HTMLElement {\n    const chip = document.createElement('span');\n    chip.setAttribute(TYPE_ATTRIBUTE, VALUE_TYPE);\n    chip.setAttribute(KEY_ATTRIBUTE, key);\n    chip.setAttribute('contenteditable', 'false');\n    this._label(chip);\n\n    return chip;\n  }\n\n  // A chip reads as the value does in the viewed block — its number, the\n  // ellipsis while that loads, else the em dash — so opening the editor moves\n  // no word; or as its name, when names are toggled on. A key with no value on\n  // the page reads as the key itself, marked missing.\n  private _label(chip: HTMLElement): void {\n    const key = chip.getAttribute(KEY_ATTRIBUTE);\n    const value = this.config.values()[key];\n\n    chip.textContent = !value\n      ? key\n      : this.config.showNames() ? value.name : valueText(value);\n    chip.title = value?.name ?? key;\n    chip.toggleAttribute(MISSING_ATTRIBUTE, !value);\n  }\n\n  // The html Froala hands out, with every chip back to its token.\n  private _toTokens(html: string): string {\n    if (!html.includes(KEY_ATTRIBUTE)) {\n      return html;\n    }\n\n    const template = document.createElement('template');\n    template.innerHTML = html;\n    template.content.querySelectorAll(CHIP_SELECTOR).forEach((chip) => {\n      chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE)));\n    });\n\n    return template.innerHTML;\n  }\n\n  private _onKeydown(event: KeyboardEvent): boolean | void {\n    // Any key but a lone modifier starts a new edit.\n    if (!MODIFIER_KEYS.includes(event.key)) {\n      this.config.changed();\n    }\n\n    const deleting = event.key === 'Backspace' || event.key === 'Delete';\n\n    // Deleting across several selected cells goes through, values and all:\n    // Froala saves an undo step and empties the cells, and what that took is\n    // reported once they are empty.\n    if (deleting && this._editor.el.querySelectorAll(SELECTED_CELL).length > 1) {\n      const before = this._chipCounts();\n      setTimeout(() => this._reportRemoved(before));\n\n      return undefined;\n    }\n\n    const range = this._range();\n    if (!range) {\n      return;\n    }\n\n    if (range.collapsed) {\n      if (!deleting) {\n        return;\n      }\n\n      const chip = this._adjacentChip(event.key === 'Backspace', this._granularity(event));\n\n      return chip ? this._block(event, [chip], null) : undefined;\n    }\n\n    // A selection is replaced by a deleting key, Enter, a typed character or\n    // a cut.\n    const typing = event.key.length === 1 && !event.ctrlKey && !event.metaKey;\n    const cutting = (event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'x';\n    if (!deleting && !typing && !cutting && event.key !== 'Enter') {\n      return;\n    }\n\n    const chips = this._chipsIn(range);\n\n    return chips.length ? this._block(event, chips, range) : undefined;\n  }\n\n  // The same rule for edits that arrive without a key Froala sees: a phone\n  // keyboard, an input method, a spell-check replacement.\n  private _onBeforeInput(event: InputEvent): void {\n    const range = this._range();\n    if (this._removing || !range) {\n      return;\n    }\n\n    if (range.collapsed) {\n      const backward = event.inputType.endsWith('Backward');\n      if (event.inputType.startsWith('delete')) {\n        const chip = this._adjacentChip(backward, event.inputType.includes('Word') ? 'word' : 'character');\n        if (chip) {\n          this._block(event, [chip], null);\n        }\n      }\n\n      return;\n    }\n\n    const chips = this._chipsIn(range);\n    if (chips.length) {\n      this._block(event, chips, range);\n    }\n  }\n\n  // Cut, drag and paste-over: stopped when the selection holds a value.\n  private _guardSelection(event: Event): boolean | void {\n    const range = this._range();\n    if (this._removing || !range || range.collapsed) {\n      return;\n    }\n\n    const chips = this._chipsIn(range);\n\n    return chips.length ? this._block(event, chips, range) : undefined;\n  }\n\n  // Copying a value copies its token, and the page it was copied on, so\n  // pasting it back on this page — in this block or another — makes it a chip\n  // again.\n  private _onCopy(event: ClipboardEvent): void {\n    const range = this._range();\n    if (!range || range.collapsed || !this._chipsIn(range).length) {\n      return;\n    }\n\n    const holder = document.createElement('div');\n    holder.append(range.cloneContents());\n    holder.querySelectorAll(CHIP_SELECTOR).forEach((chip) => {\n      chip.replaceWith(valueToken(chip.getAttribute(KEY_ATTRIBUTE)));\n    });\n\n    event.clipboardData.setData('text/plain', this._plainText(holder));\n    event.clipboardData.setData('text/html', holder.innerHTML);\n    event.clipboardData.setData(SCOPE_TYPE, this.config.scope());\n    event.preventDefault();\n  }\n\n  // What copied html reads as in plain text: a paragraph on its own lines, a\n  // table's cells tab-separated and its rows on lines of their own. That is\n  // the browser's innerText, which only text laid out on the page has — so\n  // the holder is put offscreen (not hidden: hidden text has none) while it is\n  // read.\n  private _plainText(holder: HTMLElement): string {\n    holder.style.cssText = 'position: fixed; left: -10000px; top: 0';\n    document.body.append(holder);\n    const text = holder.innerText;\n    holder.remove();\n\n    return text;\n  }\n\n  private _onClick(event: MouseEvent): void {\n    const chip = (event.target as Element)?.closest?.(CHIP_SELECTOR) as HTMLElement | null;\n    if (!chip || !this._editor?.el.contains(chip)) {\n      return;\n    }\n\n    event.preventDefault();\n    // A press in a table cell can open the table's popup on mouseup, just\n    // before this click; a chip in a cell shows only its own popover.\n    this._editor.popups.hide('table.edit');\n    this.config.click(chip.getAttribute(KEY_ATTRIBUTE), chip);\n  }\n\n  private _onChip(event?: Event): boolean {\n    return !!(event?.target as Element | undefined)?.closest?.(CHIP_SELECTOR);\n  }\n\n  private _block(event: Event, chips: HTMLElement[], range: Range | null): false {\n    event.preventDefault();\n    event.stopPropagation();\n    chips.forEach((chip) => chip.animate(FLASH, FLASH_MS));\n\n    this.config.blocked({\n      count: chips.length,\n      ...(range ? { removeSelection: () => this._removeRange(range) } : {}),\n    });\n\n    return false;\n  }\n\n  private _removeRange(range: Range): void {\n    if (!this._editor) {\n      return;\n    }\n\n    const selection = this._selection();\n    this._editor.el.focus();\n    selection.removeAllRanges();\n    selection.addRange(range);\n\n    this._editor.undo.saveStep();\n    this._removing = true;\n    // The browser's own delete, so two paragraphs a selection spans join the\n    // way they would for a plain Delete.\n    document.execCommand('delete');\n    this._removing = false;\n    this._changed();\n  }\n\n  // An edit made here rather than typed: record it for undo, and tell\n  // html-editor so the draft follows.\n  private _changed(): void {\n    this._editor.undo.saveStep();\n    this._editor.events.trigger('contentChanged');\n  }\n\n  private _selection(): Selection {\n    return this._editor.el.ownerDocument.getSelection();\n  }\n\n  // The selection, when it is inside this editor.\n  private _range(): Range | null {\n    const selection = this._editor ? this._selection() : null;\n    if (!selection?.rangeCount) {\n      return null;\n    }\n\n    const range = selection.getRangeAt(0);\n\n    return this._editor.el.contains(range.commonAncestorContainer) ? range : null;\n  }\n\n  private _chipsIn(range: Range): HTMLElement[] {\n    return this._chips().filter((chip) => range.intersectsNode(chip));\n  }\n\n  // The chip a collapsed cursor would delete into: stretch the selection by\n  // what the key deletes, see what it covers, and put it back. Letting the\n  // browser stretch it handles every shape the html takes — a chip inside a\n  // bold span, at a line's end, beside an empty text node.\n  private _adjacentChip(backward: boolean, granularity: string): HTMLElement | null {\n    const selection = this._selection();\n    const range = selection.getRangeAt(0).cloneRange();\n\n    selection.modify('extend', backward ? 'backward' : 'forward', granularity);\n    const chip = selection.rangeCount\n      ? this._chipsIn(selection.getRangeAt(0))[0] ?? null\n      : null;\n\n    selection.removeAllRanges();\n    selection.addRange(range);\n\n    return chip;\n  }\n\n  // How far a deleting key reaches: a word with Ctrl/Alt, to the line's start\n  // with Cmd on a Mac, one character otherwise.\n  private _granularity(event: KeyboardEvent): string {\n    if (event.metaKey) {\n      return 'lineboundary';\n    }\n\n    return event.ctrlKey || event.altKey ? 'word' : 'character';\n  }\n}\n"]}