u2ui 1.5.8 → 1.5.11

package/js/rte/PLAN.md

@@ -70,6 +70,19 @@ Nothing did that afterwards — the bold mark recognizes `<b>`, but only a mark
 command ever makes an element canonical — so a strict list would otherwise have
 turned every pasted emphasis into plain text.
 
+Not every `text/html` flavor is html. A pdf viewer offers its selection as one
+while putting plain text with line breaks inside it, and importing that as html
+collapsed them all into a single line. `ExternalInput` now takes a paste over
+only when the flavor carries markup, so text stays with the browser, which
+inserts it with its breaks intact.
+
+Keeping the content of an unlisted element is right for almost all of them, and
+wrong for the few a browser never renders the children of: unwrapping a `<style>`
+from a word processor left its stylesheet standing in the text. `SanitizePolicy`
+now carries a `drop` list — `base head link meta noscript script style template
+title` — that `narrow()` removes with their content, while everything else keeps
+dissolving into what the author wrote.
+
 A native paste now meets the attribute policy. Nothing is parsed there — the
 browser inserts its own payload — so it was the one import path without an
 allowlist, and layout ids, tracking attributes and inline styles came straight

package/js/rte/src/client/README.md

@@ -94,10 +94,12 @@ arrow keys move through it, Enter takes the current entry, Escape closes the lis
 before it closes the form, and a pointer does the same. One question is in flight
 at a time, and a late answer to a word that has since changed is dropped.
 
-Contextual UI goes with the editing session and comes back with it: a module
-draws on `u2-rte-activate` as well as on selection and content changes, because
-returning to the field a caret was already in is no selection change and would
-otherwise leave its handles or its form behind.
+Contextual UI goes with the editing session and comes back with it. `follows()`
+owns that lifecycle for every module that draws one: selection, content, and the
+session's return, because coming back to the selection a module was already
+showing for is no selection change and would otherwise leave its handles or its
+form behind. A module that has more of its own to hear ends it with the same
+signal, the way the table handles listen for typing.
 
 Everything this client draws goes into one `Chrome`: its toolbar, the contextual
 handles, the link form, the source dialog. A module receives it as `chrome` in

package/js/rte/src/client/contextual.js

@@ -0,0 +1,22 @@
+// When a contextual UI is drawn, for every module that draws one. It follows the
+// selection and the content of one surface, comes back with the session and goes
+// with it — coming back to the selection it was already showing for is no
+// selection change, so only the session's return says it belongs on screen again.
+//
+// What to draw is the module's own business; this only says when.
+export function follows(surface, draw, close) {
+    const controller = new surface.element.ownerDocument.defaultView.AbortController();
+    const listen = {signal: controller.signal};
+    for (const type of ['u2-rte-selectionchange', 'u2-rte-change', 'u2-rte-activate']) {
+        surface.addEventListener(type, draw, listen);
+    }
+    surface.addEventListener('u2-rte-deactivate', close, listen);
+    return {
+        // A module with more of its own to hear ends it with the same signal.
+        signal: controller.signal,
+        dispose() {
+            controller.abort();
+            close();
+        },
+    };
+}

package/js/rte/src/client/images.js

@@ -1,6 +1,7 @@
 import {elementAttributes, selectedElement} from '../command/element.js';
 import {inlineUi} from '../config/config.js';
 import {caretAfter} from '../ui/caret.js';
+import {follows} from './contextual.js';
 import {Handles} from '../ui/handles.js';
 import {panelGap, place} from '../ui/place.js';
 
@@ -93,18 +94,9 @@ export function imageTools({selector = 'img', minimum = 16} = {}) {
             const state = editors.get(editor);
             const view = state?.views.get(surface);
             if (!view) throw new DOMException('The image surface is not set up', 'InvalidStateError');
-            const controller = new state.document.defaultView.AbortController();
-            const listen = {signal: controller.signal};
-            const sync = () => track(state, view, match);
-            surface.addEventListener('u2-rte-selectionchange', sync, listen);
-            surface.addEventListener('u2-rte-change', sync, listen);
-            // What a session's end takes away, its beginning brings back: coming
-            // back to the same selection is no selection change to hear about.
-            surface.addEventListener('u2-rte-activate', sync, listen);
-            surface.addEventListener('u2-rte-deactivate', () => close(state, surface), listen);
+            const following = follows(surface, () => track(state, view, match), () => close(state, surface));
             return {dispose() {
-                controller.abort();
-                close(state, surface);
+                following.dispose();
                 state.views.delete(surface);
             }};
         },
@@ -192,8 +184,12 @@ function position(state, box = null) {
     for (const handle of HANDLES) {
         state.handles.place(handle.name, rect.left + rect.width * handle.x, rect.top + rect.height * handle.y);
     }
-    // Below the image, clear of the handles sitting on its lower edge.
-    place(state.alt, state.active.view.surface, {align: 'start', prefer: 'below', gap: panelGap, on: rect});
+    // Below the image and below its handles: they sit on its edges and reach
+    // past them, so what the form hangs off is the pair of them.
+    const lowest = Math.max(rect.bottom, ...HANDLES.map(handle =>
+        state.handles.button(handle.name)?.getBoundingClientRect().bottom ?? 0));
+    place(state.alt, state.active.view.surface, {align: 'start', prefer: 'below', gap: panelGap,
+        on: {left: rect.left, width: rect.width, top: rect.top, bottom: lowest}});
 }
 
 function build(state) {

package/js/rte/src/client/link.js

@@ -1,6 +1,8 @@
 import {inlineUi} from '../config/config.js';
+import {rangeRect} from '../browser/range-rect.js';
 import {linkHtml} from '../mark/standard.js';
 import {caretAfter} from '../ui/caret.js';
+import {follows} from './contextual.js';
 import {panelGap, place} from '../ui/place.js';
 import {valueMark} from '../command/mark.js';
 
@@ -124,17 +126,9 @@ export function linkEditor({
         attach({editor, surface}) {
             const state = editors.get(editor);
             if (!state) throw new DOMException('The link extension is not set up', 'InvalidStateError');
-            const controller = new state.document.defaultView.AbortController();
-            const listen = {signal: controller.signal};
-            surface.addEventListener('u2-rte-selectionchange', () => follow(state, surface), listen);
-            surface.addEventListener('u2-rte-change', () => follow(state, surface), listen);
-            // What a session's end takes away, its beginning brings back: coming
-            // back to the same selection is no selection change to hear about.
-            surface.addEventListener('u2-rte-activate', () => follow(state, surface), listen);
-            surface.addEventListener('u2-rte-deactivate', () => close(state, surface), listen);
+            const following = follows(surface, () => follow(state, surface), () => close(state, surface));
             return {dispose() {
-                controller.abort();
-                close(state, surface);
+                following.dispose();
                 state.views.delete(surface);
             }};
         },
@@ -420,13 +414,20 @@ function position(state) {
         align: 'start',
         prefer: 'below',
         gap: panelGap,
-        on: active.element?.getBoundingClientRect() || null,
+        // What the link covers, not the box it occupies: an inline element that
+        // holds an image is a line box of text height, nowhere near the picture
+        // someone is looking at.
+        on: active.element ? rangeRect(contents(active.element), {root: active.surface.element}) : null,
     });
 }
 
-// The node the surface's saved selection starts in.
+// The node the surface's saved selection starts in — or the one it holds, when
+// that is a single element: an image's link is on the image, not on the block the
+// range around it starts in.
 function at(surface) {
-    return surface.selection?.range().startContainer || null;
+    const range = surface.selection?.range();
+    if (!range) return null;
+    return range.startContainer.childNodes?.[range.startOffset] ?? range.startContainer;
 }
 
 // The contents of one element, as a range.

package/js/rte/src/client/tables.js

@@ -1,6 +1,7 @@
 import {Tables} from '../command/table.js';
 import {inlineUi} from '../config/config.js';
 import {elementOf} from '../selection/ownership/ownership.js';
+import {follows} from './contextual.js';
 import {Handles} from '../ui/handles.js';
 
 
@@ -54,19 +55,13 @@ export function tableTools({tag = 'table'} = {}) {
             const state = editors.get(editor);
             const view = state?.views.get(surface);
             if (!view) throw new DOMException('The table surface is not set up', 'InvalidStateError');
-            const controller = new state.document.defaultView.AbortController();
-            const listen = {signal: controller.signal};
             const sync = () => track(state, view);
-            surface.addEventListener('u2-rte-selectionchange', sync, listen);
-            surface.addEventListener('u2-rte-change', sync, listen);
-            // What a session's end takes away, its beginning brings back: coming
-            // back to the same selection is no selection change to hear about.
-            surface.addEventListener('u2-rte-activate', sync, listen);
-            surface.addEventListener('u2-rte-deactivate', () => close(state, surface), listen);
-            surface.element.addEventListener('input', sync, listen);
+            const following = follows(surface, sync, () => close(state, surface));
+            // A table's own shape changes with what is typed in it, wherever the
+            // caret happens to be.
+            surface.element.addEventListener('input', sync, {signal: following.signal});
             return {dispose() {
-                controller.abort();
-                close(state, surface);
+                following.dispose();
                 state.views.delete(surface);
             }};
         },

package/js/rte/src/command/mark.js

@@ -189,8 +189,8 @@ function selected(edit) {
 function canApply(edit, adapter, mark) {
     if (!selected(edit)) return false;
     const wrapper = adapter.render(mark, edit.document);
-    for (const node of edit.range.textNodes()) {
-        if (!node.data || blocked(edit, node) || has(edit, adapter, mark, node)) continue;
+    for (const node of markable(edit, adapter)) {
+        if (has(edit, adapter, mark, node)) continue;
         for (let element = node.parentElement; element && element !== edit.element; element = element.parentElement) {
             if (edit.model.block(element) || isEditingBoundary(element)) break;
             const current = adapter.parse(element);
@@ -224,8 +224,7 @@ function markState(edit, adapter, mark) {
     }
     let active = false;
     let inactive = false;
-    for (const node of edit.range.textNodes()) {
-        if (!node.data || blocked(edit, node)) continue;
+    for (const node of markable(edit, adapter)) {
         has(edit, adapter, mark, node) ? active = true : inactive = true;
         if (active && inactive) return 'mixed';
     }
@@ -265,8 +264,7 @@ function marksAt(edit, adapters, node) {
 function marksIn(edit, adapter) {
     const marks = [];
     if (!edit.range) return marks;
-    for (const node of edit.range.textNodes()) {
-        if (!node.data || blocked(edit, node)) continue;
+    for (const node of markable(edit, adapter)) {
         for (let element = node.parentElement; element && element !== edit.element; element = element.parentElement) {
             if (isEditingBoundary(element) || edit.model.block(element)) break;
             const mark = adapter.parse(element);
@@ -290,7 +288,18 @@ function apply(edit, adapter, mark, range) {
                 changed.push(wrapper);
                 continue;
             }
-            if (node.nodeType !== Node.ELEMENT_NODE || isEditingBoundary(node) || edit.model.atomic(node)) continue;
+            if (node.nodeType !== Node.ELEMENT_NODE || isEditingBoundary(node)) continue;
+            // An atomic element carries a mark the way a word does: nothing can
+            // be marked inside it, so the mark goes around it.
+            if (edit.model.atomic(node)) {
+                if (!covered(range, node) || !wrappable(edit, adapter, mark, node)) continue;
+                const wrapper = adapter.render(mark, edit.document);
+                if (!edit.model.allows(parent, wrapper)) continue;
+                edit.map.wrap([node], wrapper);
+                edit.transaction.touch(wrapper);
+                changed.push(wrapper);
+                continue;
+            }
             if (covered(range, node) && reusable(edit, adapter, node)) {
                 const current = adapter.parse(node);
                 if (current && !current.conflicts(mark)) {
@@ -491,6 +500,29 @@ function marked(edit, adapter, mark, node) {
     return found;
 }
 
+// What a mark can sit on inside the range: the text it formats, and — for a mark
+// about content — the atomic elements that have no text to format. Everything
+// asking what is marked, what could be, and what to replace asks this.
+function markable(edit, adapter) {
+    if (!edit.range) return [];
+    return [...edit.range.textNodes().filter(node => node.data && !blocked(edit, node)),
+        ...atomics(edit, adapter)];
+}
+
+// The atomic elements in the range a content mark can sit on: nothing inside one
+// can carry a mark, so the mark is around it — and a text mark has no business
+// with them at all.
+function atomics(edit, adapter) {
+    if (adapter.covers !== 'content' || !edit.range) return [];
+    return edit.range.roots().filter(node => node.nodeType === Node.ELEMENT_NODE
+        && !isEditingBoundary(node) && edit.model.atomic(node));
+}
+
+function wrappable(edit, adapter, mark, node) {
+    return adapter.covers === 'content' && node?.nodeType === Node.ELEMENT_NODE
+        && !isEditingBoundary(node) && edit.model.atomic(node) && !has(edit, adapter, mark, node);
+}
+
 function has(edit, adapter, mark, node) {
     for (let element = elementOf(node); element && element !== edit.element; element = element.parentElement) {
         if (isEditingBoundary(element) || edit.model.block(element)) return false;

package/js/rte/src/core/core.js

@@ -12,8 +12,7 @@ export class Rte extends EventTarget {
     #retained = new Set();
     #active = null;
     #unfocused = false;
-    #pointer = null;
-    #handed = false;
+    #press = null;
     #controller;
 
     constructor(root = document, options = {}) {
@@ -173,15 +172,15 @@ export class Rte extends EventTarget {
         // on that element — a host's own handler, a css `:focus` rule — sees it
         // too. Leaving it focused instead is worse: a caret that types into a
         // surface with no session behind it.
-        if (surface && this.#pointer && !this.#pointer.includes(surface.element)) {
+        if (surface && this.#press && !this.#press.path.includes(surface.element)) {
             this.#unfocused = true;
             this.activate(null);
             // Handing the focus back once per press. An engine that answers a
             // blur by focusing again — the selection is still in there, after
             // all — would otherwise trade focus with the editor for as long as
             // the button is down, and the session stays refused either way.
-            if (!this.#handed) {
-                this.#handed = true;
+            if (!this.#press.handed) {
+                this.#press.handed = true;
                 editable.blur();
             }
             return;
@@ -207,8 +206,7 @@ export class Rte extends EventTarget {
 
     #pointerDown = event => {
         const path = event.composedPath();
-        this.#pointer = path;
-        this.#handed = false;
+        this.#press = {path, handed: false};
         const editing = this.#editing(path[0]);
         // The right button opens a menu about what is selected; moving the
         // selection to what it was aimed at is what makes the menu useless.
@@ -233,7 +231,7 @@ export class Rte extends EventTarget {
     }
 
     #pointerDone = () => {
-        this.#pointer = null;
+        this.#press = null;
     };
 
     #selectionChange = () => {

package/js/rte/src/input/README.md

@@ -103,7 +103,10 @@ const external = new ExternalInput(surface, {
 
 For `insertFromPaste` and `insertFromDrop`, the contenteditable Input Events
 contract supplies rich and plain data in `dataTransfer` plus the DOM range that
-would be replaced. The adapter takes over only when `text/html` is present. It
+would be replaced. The adapter takes over only when `text/html` is present and
+carries markup: a pdf viewer labels its plain selection `text/html`, and
+importing that as html would collapse the line breaks the text flavor keeps, so
+a flavor without a single tag is left to the browser. It
 prevents native insertion first, sanitizes into a detached `DocumentFragment`,
 optionally cleans presentation cumulatively through the selected level, and
 passes the result and exact target range to the registered command. Drop thus

package/js/rte/src/input/external-input.js

@@ -97,7 +97,7 @@ export class ExternalInput {
     #beforeInput = event => {
         if (!this.#owns(event) || !INPUTS.has(event.inputType) || !event.cancelable
             || event.defaultPrevented || event.isComposing || isPlainTextHost(this.#root)) return;
-        if (!hasHtml(event.dataTransfer)) return;
+        if (!hasMarkup(event.dataTransfer)) return;
         event.preventDefault();
         try {
             const html = event.dataTransfer.getData('text/html');
@@ -123,8 +123,13 @@ export class ExternalInput {
     }
 }
 
-function hasHtml(transfer) {
+// An html flavor carrying no markup is text that was labelled html — a pdf viewer offers its
+// selection that way. Importing it as html would collapse the line breaks it carries, while the
+// browser inserts the text flavor with them intact, so that one stays with the browser.
+function hasMarkup(transfer) {
     if (!transfer || typeof transfer.getData !== 'function') return false;
     const types = [...(transfer.types || [])].map(type => String(type).toLowerCase());
-    return types.includes('text/html');
+    if (!types.includes('text/html')) return false;
+    if (!types.includes('text/plain')) return true;
+    return /<[a-z!/]/i.test(transfer.getData('text/html'));
 }

package/js/rte/src/mark/README.md

@@ -17,6 +17,13 @@ an attribute, a style, or something custom. `standard.js` provides the compact
 default HTML policies for bold, italic, underline, strike, code, and links. The
 range commands apply or remove those representations on selected text.
 
+## What a mark is about
+
+A mark covers `text` by default: bold, italic, a content class. `covers:
+"content"` says the other kind — a link is not about the letters but about what
+they point at, so it also goes around content that has no text of its own. An
+image can be a link; an emphasized image is nothing, and stays unmarked.
+
 ## Public contract
 
 `MarkType` describes one kind of formatting. `bold`, `link`, and `color` are

package/js/rte/src/mark/dom-adapter.js

@@ -10,8 +10,9 @@ export class MarkAdapter {
     #write;
     #clear;
     #reuse;
+    #covers;
 
-    constructor(type, {selector, tag, read = TRUE, write, clear, reuse = false, render} = {}) {
+    constructor(type, {selector, tag, read = TRUE, write, clear, reuse = false, render, covers = 'text'} = {}) {
         if (!(type instanceof MarkType)) throw new TypeError('A mark adapter requires a mark type');
         if (typeof selector !== 'string' || !selector.trim()) {
             throw new TypeError('A mark adapter requires a non-empty selector');
@@ -25,6 +26,7 @@ export class MarkAdapter {
         if (reuse && !write) throw new TypeError('A reusable mark adapter requires write');
         if (render !== undefined && typeof render !== 'function') throw new TypeError('A mark renderer must be a function');
         if (render && tag !== undefined) throw new TypeError('A custom mark renderer cannot be combined with tag');
+        if (covers !== 'text' && covers !== 'content') throw new TypeError('A mark covers "text" or "content"');
         if (!render && (typeof tag !== 'string' || !/^[a-z][a-z0-9-]*$/.test(tag))) {
             throw new TypeError('A mark adapter requires a lowercase HTML tag');
         }
@@ -34,6 +36,7 @@ export class MarkAdapter {
         this.#write = write;
         this.#clear = clear;
         this.#reuse = reuse;
+        this.#covers = covers;
         this.#render = render || ((document, value) => {
             const element = document.createElement(tag);
             write?.(element, value);
@@ -44,6 +47,10 @@ export class MarkAdapter {
     get type() { return this.#type; }
     get selector() { return this.#selector; }
     get reusable() { return !!this.#reuse; }
+    // What the mark is about: the text it formats, or the content it applies to.
+    // A link is the second kind — an image can be one, an emphasized image is
+    // nothing — and only that kind goes around content with no text of its own.
+    get covers() { return this.#covers; }
     get removable() { return !!this.#clear; }
 
     parse(element) {

package/js/rte/src/mark/standard.js

@@ -18,6 +18,8 @@ export const codeHtml = element(code, 'code', 'code');
 export const linkHtml = new MarkAdapter(link, {
     selector: 'a[href]',
     tag: 'a',
+    // A link is about the content, not about its text: an image can be one.
+    covers: 'content',
     read: readLink,
     write: writeLink,
     clear: clearLink,

package/js/rte/src/sanitize/README.md

@@ -13,8 +13,15 @@ repairs editable document shape.
 - `elements`: element names the security policy can accept;
 - `attributes`: global (`*`) and per-element attribute names;
 - `protocols`: per-element rules for URL attributes;
+- `drop`: element names that `narrow()` removes with their content;
 - `comments` and `dataAttributes`: explicit booleans, both false by default.
 
+An element outside `elements` keeps its content — dropping it would lose text the
+author wrote. `drop` names the exception: elements a browser never renders the
+children of, where unwrapping would turn a stylesheet, a script, or document
+metadata into visible text. It defaults to `base head link meta noscript script
+style template title` and, like every default, an application may replace it.
+
 The supplied `sanitizePolicy` accepts the `document` element preset, ordinary
 editor metadata, and conservative web URLs. An image may carry a `data:` URL,
 because an image executes nothing — not even an SVG one, which browsers draw in

package/js/rte/src/sanitize/policy.js

@@ -27,10 +27,18 @@ const DEFAULT_PROTOCOLS = Object.freeze({
     q: Object.freeze({cite: Object.freeze(['http', 'https', 'relative'])}),
 });
 
+// Elements a browser never renders the children of. Unwrapping one turns source — a stylesheet, a
+// script, document metadata — into visible text, so these go with their content. Every other unknown
+// element keeps its content: dropping it would lose text the author wrote.
+const DEFAULT_DROP = Object.freeze([
+    'base', 'head', 'link', 'meta', 'noscript', 'script', 'style', 'template', 'title',
+]);
+
 export const sanitizeDefaults = Object.freeze({
     elements: elementPresets.document,
     attributes: DEFAULT_ATTRIBUTES,
     protocols: DEFAULT_PROTOCOLS,
+    drop: DEFAULT_DROP,
     comments: false,
     dataAttributes: false,
 });
@@ -41,6 +49,7 @@ export class SanitizePolicy {
 
     constructor(options = {}) {
         this.elements = names(options.elements ?? sanitizeDefaults.elements, NAME, 'element');
+        this.drop = names(options.drop ?? sanitizeDefaults.drop, NAME, 'element');
         this.#attributes = groups(options.attributes ?? sanitizeDefaults.attributes, ATTRIBUTE, 'attribute');
         this.#protocols = protocolGroups(options.protocols ?? sanitizeDefaults.protocols);
         this.attributeNames = Object.freeze(unique(Object.values(this.#attributes).flat()));
@@ -69,8 +78,9 @@ export class SanitizePolicy {
     }
 
     // Reduces a subtree to the elements this policy allows, keeping the content
-    // of the rest. Parsed input gets this from the safe sink; markup the browser
-    // inserted itself has to be narrowed afterwards.
+    // of the rest — except the `drop` elements, which go with theirs. Parsed input
+    // gets this from the safe sink; markup the browser inserted itself has to be
+    // narrowed afterwards.
     //
     // `skip` leaves an element to a later stage. Structural repair already
     // removes what the content model rejects, and it does so knowing that
@@ -86,8 +96,15 @@ export class SanitizePolicy {
             : this.elements.filter(name => elements.includes(name));
         const changed = [];
         for (const element of descendants(root).reverse()) {
-            if (preserve?.has(element) || allowed.includes(element.localName)) continue;
+            if (preserve?.has(element)) continue;
             if (!element.parentNode || skip?.(element)) continue;
+            if (this.drop.includes(element.localName)) {
+                if (map) map.remove(element);
+                else element.remove();
+                changed.push(element);
+                continue;
+            }
+            if (allowed.includes(element.localName)) continue;
             const equivalent = alias?.[element.localName];
             if (equivalent && allowed.includes(equivalent)) {
                 const replacement = element.ownerDocument.createElement(equivalent);

package/js/rte/src/ui/place.js

@@ -6,10 +6,11 @@ import {rangeRect} from '../browser/range-rect.js';
 //
 // A UI that belongs to one element rather than to the selection passes that
 // element's rect as `on`: what it points at should not shift with the caret.
-// One distance for every panel that hangs off an element rather than off the
-// selection: the handles on a frame's edge reach about this far, and two panels
-// answering for the same element must not sit at two different heights.
-export const panelGap = 16;
+// One distance for every panel that hangs off something, and between two of them
+// — near enough to read as belonging to it. What must be cleared belongs in the
+// rect a caller anchors on, not in this number: a frame's handles reach past the
+// element they sit on, and the panel below them is told so.
+export const panelGap = 8;
 
 export function place(element, surface, {align = 'center', prefer = 'above', gap = 28, on = null} = {}) {
     const range = on ? null : surface.selection?.range();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u2ui",
-  "version": "1.5.8",
+  "version": "1.5.11",
   "description": "HTML Advanced: More Capabilities, Same Feel, Same Simplicity",
   "keywords": ["web-components","pattern-library","component-library","ui-toolkit","design-system"],
   "author": "Tobias Buschor",