@react-x11/components 0.8.0 → 0.10.0

package/dist/rich-text-editor/html.d.ts

@@ -0,0 +1,145 @@
+import type { Element as DhElement } from 'domhandler';
+import { DOMParser, DOMSerializer, Fragment } from 'prosemirror-model';
+import type { Node as PMNode, ParseOptions, Schema, Slice } from 'prosemirror-model';
+/** A `style` attribute, as the declaration object `DOMParser`'s style rules
+ *  and a schema's `getAttrs` read: `getPropertyValue` for the former,
+ *  camelCase properties for the latter. */
+export declare class ShimStyle {
+    [property: string]: unknown;
+    private readonly _names;
+    private readonly _values;
+    constructor(css: string);
+    private _set;
+    get length(): number;
+    item(index: number): string;
+    getPropertyValue(name: string): string;
+    get cssText(): string;
+}
+declare abstract class ShimNode {
+    abstract readonly nodeType: number;
+    abstract readonly nodeName: string;
+    ownerDocument: ShimDocument;
+    parentNode: ShimParent | null;
+    nextSibling: ShimNode | null;
+    previousSibling: ShimNode | null;
+    abstract get textContent(): string;
+    contains(other: ShimNode | null): boolean;
+}
+declare abstract class ShimParent extends ShimNode {
+    readonly childNodes: ShimNode[];
+    get firstChild(): ShimNode | null;
+    get lastChild(): ShimNode | null;
+    get textContent(): string;
+    appendChild<T extends ShimNode>(child: T): T;
+    removeChild<T extends ShimNode>(child: T): T;
+}
+export declare class ShimText extends ShimNode {
+    nodeValue: string;
+    readonly nodeType = 3;
+    readonly nodeName = "#text";
+    constructor(doc: ShimDocument, nodeValue: string);
+    get textContent(): string;
+}
+export declare class ShimElement extends ShimParent {
+    /** The parser's node, which selectors are matched against. */
+    readonly source: DhElement;
+    readonly nodeType = 1;
+    readonly nodeName: string;
+    readonly tagName: string;
+    readonly localName: string;
+    readonly namespaceURI = "http://www.w3.org/1999/xhtml";
+    readonly style: ShimStyle;
+    private readonly _attrs;
+    constructor(doc: ShimDocument, 
+    /** The parser's node, which selectors are matched against. */
+    source: DhElement);
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+    get attributes(): {
+        name: string;
+        value: string;
+    }[];
+    get id(): string;
+    get className(): string;
+    get classList(): {
+        contains(name: string): boolean;
+        length: number;
+    };
+    matches(selector: string): boolean;
+    querySelector(selector: string): ShimElement | null;
+    querySelectorAll(selector: string): ShimElement[];
+}
+export declare class ShimDocument extends ShimParent {
+    readonly nodeType = 9;
+    readonly nodeName = "#document";
+    private readonly _shims;
+    constructor();
+    createTextNode(text: string): ShimText;
+    /** @internal — the shim a parser element became. */
+    shimOf(node: DhElement): ShimElement | null;
+    /** @internal */
+    adopt(node: DhElement): ShimElement;
+}
+/**
+ * HTML → the element DOMParser reads — the counterpart of prosemirror-view's
+ * `readHTML`: leading `<meta>`s dropped (a browser's clipboard starts with
+ * one), and a fragment that begins inside a table given its table back.
+ */
+export declare function readHTML(html: string): ShimElement;
+/** A whole document of `schema`, from HTML. */
+export declare function docFromHTML(schema: Schema, html: string, options?: ParseOptions): PMNode;
+/** A slice of `schema`, from HTML — open at the sides, the shape
+ *  `replaceSelection` wants. */
+export declare function sliceFromHTML(schema: Schema, html: string, options?: ParseOptions): Slice;
+/** Parse an element already read with {@link readHTML}. */
+export declare function sliceFromElement(parser: DOMParser, dom: ShimElement, options?: ParseOptions): Slice;
+type OutNode = OutElement | OutText | OutFragment;
+declare class OutText {
+    nodeValue: string;
+    readonly nodeType = 3;
+    constructor(nodeValue: string);
+}
+declare class OutFragment {
+    readonly nodeType = 11;
+    readonly childNodes: OutNode[];
+    appendChild<T extends OutNode>(child: T): T;
+    get firstChild(): OutNode | null;
+}
+declare class OutElement {
+    readonly nodeType = 1;
+    readonly tagName: string;
+    readonly nodeName: string;
+    readonly attrs: Map<string, string>;
+    readonly childNodes: OutNode[];
+    /** DOMSerializer writes a `style` attribute as `style.cssText`. */
+    readonly style: {
+        cssText: string;
+    };
+    constructor(tag: string);
+    setAttribute(name: string, value: unknown): void;
+    setAttributeNS(_ns: string, name: string, value: unknown): void;
+    getAttribute(name: string): string | null;
+    removeAttribute(name: string): void;
+    appendChild<T extends OutNode>(child: T): T;
+    get firstChild(): OutNode | null;
+}
+/** Serialize content through the schema's `toDOM`, as a fragment of the
+ *  printed tree — the clipboard adds its own attribute before printing. */
+export declare function renderFragment(schema: Schema, content: Fragment): {
+    html(): string;
+    firstElement(): OutElement | null;
+};
+/**
+ * The HTML a copy offers other applications — prosemirror-view's
+ * `serializeForClipboard`, printed rather than put in a DOM: the content
+ * through `serializer`, wrapped in a table when it starts with a table's
+ * parts (a cell alone is not HTML any reader keeps), and ProseMirror's
+ * `data-pm-slice` marker on the first element, so a ProseMirror editor
+ * anywhere — this one, or one in a browser — pastes it back with its open
+ * sides and its context intact.
+ */
+export declare function clipboardHTML(serializer: DOMSerializer, content: Fragment, openStart: number, openEnd: number, context: unknown[]): string;
+/** A document or a fragment as HTML, through the schema's `toDOM`. */
+export declare function htmlFromContent(schema: Schema, content: Fragment | PMNode): string;
+export {};
+//# sourceMappingURL=html.d.ts.map

package/dist/rich-text-editor/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/rich-text-editor/html.ts"],"names":[],"mappings":"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"}

package/dist/rich-text-editor/html.js

@@ -0,0 +1,516 @@
+// HTML in and out of a document, through ProseMirror's own DOMParser and
+// DOMSerializer — with no DOM.
+//
+// Both classes are written against the browser's DOM, and both are still the
+// right thing to use: every schema in the ecosystem already says how it reads
+// HTML (`parseDOM` rules) and how it writes it (`toDOM`), so going through
+// them makes a paste from a browser, `format="html"` and a copy another
+// application can read work for *any* schema — the default one here,
+// prosemirror-schema-basic's, a TipTap extension's — with nothing written per
+// node. Reimplementing either would mean a second reading of every schema's
+// rules, and the first one to disagree with ProseMirror's would be a bug.
+//
+// So this module supplies the smallest DOM each of them touches.
+//
+// **Reading.** htmlparser2 builds the tree — already installed, for the
+// reason `src/html/dom.ts` gives — and it is re-dressed in nodes that answer
+// what `DOMParser` asks: `nodeType`/`nodeName`, the sibling links, the
+// attributes, `style` as a declaration block, `matches`/`querySelector`
+// through css-select, `appendChild` (its list normalization moves nodes), and
+// an `ownerDocument` that can make a text node. Selector matching runs on the
+// parser's own tree, so a structural selector sees the markup as written,
+// not after that normalization; the rules schemas actually write are a tag
+// and an attribute, which do not care.
+//
+// **Writing.** `DOMSerializer` takes a `document` option, and a four-method
+// one that builds plain objects is all it calls; they are then printed.
+import { Parser } from 'htmlparser2';
+import { DomHandler } from 'domhandler';
+import { is, selectAll, selectOne } from 'css-select';
+import { DOMParser, DOMSerializer, Fragment } from 'prosemirror-model';
+const HTML_NS = 'http://www.w3.org/1999/xhtml';
+// --- reading ---------------------------------------------------------------
+/** `font-weight` → `fontWeight`, the name a `getAttrs` reads off `style`. */
+function camel(name) {
+    return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+/** Split a declaration block on the semicolons that end declarations — not
+ *  the ones inside a `url(…)` or a quoted string. */
+function declarations(css) {
+    const out = [];
+    let depth = 0;
+    let quote = '';
+    let start = 0;
+    for (let i = 0; i < css.length; i++) {
+        const ch = css[i];
+        if (quote) {
+            if (ch === quote && css[i - 1] !== '\\')
+                quote = '';
+        }
+        else if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth = Math.max(0, depth - 1);
+        else if (ch === ';' && depth === 0) {
+            out.push(css.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(css.slice(start));
+    return out;
+}
+const STYLE_MEMBERS = new Set([
+    'length',
+    'item',
+    'getPropertyValue',
+    'cssText',
+]);
+/** A `style` attribute, as the declaration object `DOMParser`'s style rules
+ *  and a schema's `getAttrs` read: `getPropertyValue` for the former,
+ *  camelCase properties for the latter. */
+export class ShimStyle {
+    _names = [];
+    _values = new Map();
+    constructor(css) {
+        for (const decl of declarations(css)) {
+            const colon = decl.indexOf(':');
+            if (colon <= 0)
+                continue;
+            const name = decl.slice(0, colon).trim().toLowerCase();
+            const value = decl
+                .slice(colon + 1)
+                .replace(/!\s*important\s*$/i, '')
+                .trim();
+            if (!name || !value)
+                continue;
+            this._set(name, value);
+            // a browser reports the shorthand's longhand too, and rules are
+            // written against either
+            if (name === 'text-decoration')
+                this._set('text-decoration-line', value);
+        }
+    }
+    _set(name, value) {
+        if (!this._values.has(name))
+            this._names.push(name);
+        this._values.set(name, value);
+        const prop = camel(name);
+        if (!STYLE_MEMBERS.has(prop))
+            this[prop] = value;
+    }
+    get length() {
+        return this._names.length;
+    }
+    item(index) {
+        return this._names[index] ?? '';
+    }
+    getPropertyValue(name) {
+        return this._values.get(name.toLowerCase()) ?? '';
+    }
+    get cssText() {
+        return this._names.map((n) => `${n}: ${this._values.get(n)}`).join('; ');
+    }
+}
+class ShimNode {
+    ownerDocument;
+    parentNode = null;
+    nextSibling = null;
+    previousSibling = null;
+    contains(other) {
+        for (let n = other; n; n = n.parentNode) {
+            if (n === this)
+                return true;
+        }
+        return false;
+    }
+}
+class ShimParent extends ShimNode {
+    childNodes = [];
+    get firstChild() {
+        return this.childNodes[0] ?? null;
+    }
+    get lastChild() {
+        return this.childNodes[this.childNodes.length - 1] ?? null;
+    }
+    get textContent() {
+        let out = '';
+        for (const child of this.childNodes)
+            out += child.textContent;
+        return out;
+    }
+    appendChild(child) {
+        child.parentNode?.removeChild(child);
+        const last = this.lastChild;
+        child.parentNode = this;
+        child.previousSibling = last;
+        child.nextSibling = null;
+        if (last)
+            last.nextSibling = child;
+        this.childNodes.push(child);
+        return child;
+    }
+    removeChild(child) {
+        const at = this.childNodes.indexOf(child);
+        if (at < 0)
+            return child;
+        this.childNodes.splice(at, 1);
+        if (child.previousSibling)
+            child.previousSibling.nextSibling = child.nextSibling;
+        if (child.nextSibling)
+            child.nextSibling.previousSibling = child.previousSibling;
+        child.parentNode = null;
+        child.previousSibling = null;
+        child.nextSibling = null;
+        return child;
+    }
+}
+export class ShimText extends ShimNode {
+    nodeValue;
+    nodeType = 3;
+    nodeName = '#text';
+    constructor(doc, nodeValue) {
+        super();
+        this.nodeValue = nodeValue;
+        this.ownerDocument = doc;
+    }
+    get textContent() {
+        return this.nodeValue;
+    }
+}
+export class ShimElement extends ShimParent {
+    source;
+    nodeType = 1;
+    nodeName;
+    tagName;
+    localName;
+    namespaceURI = HTML_NS;
+    style;
+    _attrs;
+    constructor(doc, 
+    /** The parser's node, which selectors are matched against. */
+    source) {
+        super();
+        this.source = source;
+        this.ownerDocument = doc;
+        this.localName = source.name.toLowerCase();
+        this.tagName = this.localName.toUpperCase();
+        this.nodeName = this.tagName;
+        this._attrs = new Map(Object.entries(source.attribs ?? {}).map(([k, v]) => [
+            k.toLowerCase(),
+            v,
+        ]));
+        this.style = new ShimStyle(this._attrs.get('style') ?? '');
+    }
+    getAttribute(name) {
+        return this._attrs.get(name.toLowerCase()) ?? null;
+    }
+    hasAttribute(name) {
+        return this._attrs.has(name.toLowerCase());
+    }
+    get attributes() {
+        return [...this._attrs].map(([name, value]) => ({ name, value }));
+    }
+    get id() {
+        return this.getAttribute('id') ?? '';
+    }
+    get className() {
+        return this.getAttribute('class') ?? '';
+    }
+    get classList() {
+        const list = this.className.split(/\s+/).filter(Boolean);
+        return { contains: (name) => list.includes(name), length: list.length };
+    }
+    matches(selector) {
+        try {
+            return is(this.source, selector);
+        }
+        catch {
+            return false; // a selector css-select cannot read matches nothing
+        }
+    }
+    querySelector(selector) {
+        try {
+            const found = selectOne(selector, this.source.children);
+            return found ? this.ownerDocument.shimOf(found) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    querySelectorAll(selector) {
+        try {
+            return selectAll(selector, this.source.children)
+                .map((found) => this.ownerDocument.shimOf(found))
+                .filter((e) => e !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export class ShimDocument extends ShimParent {
+    nodeType = 9;
+    nodeName = '#document';
+    _shims = new WeakMap();
+    constructor() {
+        super();
+        this.ownerDocument = this;
+    }
+    createTextNode(text) {
+        return new ShimText(this, text);
+    }
+    /** @internal — the shim a parser element became. */
+    shimOf(node) {
+        return this._shims.get(node) ?? null;
+    }
+    /** @internal */
+    adopt(node) {
+        const shim = new ShimElement(this, node);
+        this._shims.set(node, shim);
+        return shim;
+    }
+}
+function isElementNode(node) {
+    return node.type === 'tag' || node.type === 'script' || node.type === 'style';
+}
+/**
+ * The shim tree for a parsed fragment, under `into`. An explicit stack
+ * rather than recursion: a pasted document is somebody else's markup, and a
+ * degenerately nested one should not be the thing that finds the call-stack
+ * limit (`src/html/dom.ts` measured the same walk).
+ */
+function build(doc, into, nodes) {
+    const stack = [[into, nodes]];
+    while (stack.length > 0) {
+        const [parent, kids] = stack.pop();
+        for (const kid of kids) {
+            if (kid.type === 'text') {
+                parent.appendChild(new ShimText(doc, kid.data));
+            }
+            else if (isElementNode(kid)) {
+                const shim = parent.appendChild(doc.adopt(kid));
+                if (kid.children.length > 0)
+                    stack.push([shim, kid.children]);
+            }
+            // comments, directives and CDATA: DOMParser skips them anyway
+        }
+    }
+}
+/** Elements that only parse inside a table — ProseMirror's (and jQuery's)
+ *  list, so a copied cell pastes as a cell. */
+const WRAP_MAP = {
+    thead: ['table'],
+    tbody: ['table'],
+    tfoot: ['table'],
+    caption: ['table'],
+    colgroup: ['table'],
+    col: ['table', 'colgroup'],
+    tr: ['table', 'tbody'],
+    td: ['table', 'tbody', 'tr'],
+    th: ['table', 'tbody', 'tr'],
+};
+/**
+ * HTML → the element DOMParser reads — the counterpart of prosemirror-view's
+ * `readHTML`: leading `<meta>`s dropped (a browser's clipboard starts with
+ * one), and a fragment that begins inside a table given its table back.
+ */
+export function readHTML(html) {
+    const metas = /^(\s*<meta [^>]*>)*/i.exec(html);
+    if (metas)
+        html = html.slice(metas[0].length);
+    const first = /<([a-z][^>\s]+)/i.exec(html);
+    const wrap = first ? WRAP_MAP[first[1].toLowerCase()] : undefined;
+    if (wrap) {
+        html =
+            wrap.map((n) => `<${n}>`).join('') +
+                html +
+                wrap
+                    .map((n) => `</${n}>`)
+                    .reverse()
+                    .join('');
+    }
+    const handler = new DomHandler();
+    const parser = new Parser(handler);
+    parser.write(`<body>${html}</body>`);
+    parser.end();
+    const doc = new ShimDocument();
+    build(doc, doc, handler.root.children);
+    let body = doc.childNodes.find((n) => n instanceof ShimElement && n.localName === 'body');
+    if (!body)
+        throw new Error('readHTML: the parser lost its <body>');
+    if (wrap) {
+        for (const name of wrap)
+            body = body.querySelector(name) ?? body;
+    }
+    return body;
+}
+/** A whole document of `schema`, from HTML. */
+export function docFromHTML(schema, html, options) {
+    return DOMParser.fromSchema(schema).parse(readHTML(html), options);
+}
+/** A slice of `schema`, from HTML — open at the sides, the shape
+ *  `replaceSelection` wants. */
+export function sliceFromHTML(schema, html, options) {
+    return DOMParser.fromSchema(schema).parseSlice(readHTML(html), options);
+}
+/** Parse an element already read with {@link readHTML}. */
+export function sliceFromElement(parser, dom, options) {
+    return parser.parseSlice(dom, options);
+}
+class OutText {
+    nodeValue;
+    nodeType = 3;
+    constructor(nodeValue) {
+        this.nodeValue = nodeValue;
+    }
+}
+class OutFragment {
+    nodeType = 11;
+    childNodes = [];
+    appendChild(child) {
+        append(this.childNodes, child);
+        return child;
+    }
+    get firstChild() {
+        return this.childNodes[0] ?? null;
+    }
+}
+class OutElement {
+    nodeType = 1;
+    tagName;
+    nodeName;
+    attrs = new Map();
+    childNodes = [];
+    /** DOMSerializer writes a `style` attribute as `style.cssText`. */
+    style = { cssText: '' };
+    constructor(tag) {
+        this.tagName = tag.toLowerCase();
+        this.nodeName = this.tagName.toUpperCase();
+    }
+    setAttribute(name, value) {
+        this.attrs.set(name, String(value));
+    }
+    setAttributeNS(_ns, name, value) {
+        this.setAttribute(name, value);
+    }
+    getAttribute(name) {
+        return this.attrs.get(name) ?? null;
+    }
+    removeAttribute(name) {
+        this.attrs.delete(name);
+    }
+    appendChild(child) {
+        append(this.childNodes, child);
+        return child;
+    }
+    get firstChild() {
+        return this.childNodes[0] ?? null;
+    }
+}
+function append(list, child) {
+    if (child instanceof OutFragment) {
+        list.push(...child.childNodes);
+        child.childNodes.length = 0;
+    }
+    else
+        list.push(child);
+}
+/** The whole of the `document` DOMSerializer calls. */
+const OUT_DOCUMENT = {
+    createElement: (tag) => new OutElement(tag),
+    createElementNS: (_ns, tag) => new OutElement(tag),
+    createTextNode: (text) => new OutText(text),
+    createDocumentFragment: () => new OutFragment(),
+};
+const VOID = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'source',
+    'track',
+    'wbr',
+]);
+function escapeText(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/ /g, '&nbsp;');
+}
+function escapeAttr(text) {
+    return escapeText(text).replace(/"/g, '&quot;');
+}
+function print(node) {
+    if (node instanceof OutText)
+        return escapeText(node.nodeValue);
+    if (node instanceof OutFragment)
+        return node.childNodes.map(print).join('');
+    let attrs = '';
+    for (const [name, value] of node.attrs) {
+        attrs += ` ${name}="${escapeAttr(value)}"`;
+    }
+    if (node.style.cssText && !node.attrs.has('style')) {
+        attrs += ` style="${escapeAttr(node.style.cssText)}"`;
+    }
+    if (VOID.has(node.tagName))
+        return `<${node.tagName}${attrs}>`;
+    return `<${node.tagName}${attrs}>${node.childNodes.map(print).join('')}</${node.tagName}>`;
+}
+/** Serialize content through the schema's `toDOM`, as a fragment of the
+ *  printed tree — the clipboard adds its own attribute before printing. */
+export function renderFragment(schema, content) {
+    const out = DOMSerializer.fromSchema(schema).serializeFragment(content, {
+        document: OUT_DOCUMENT,
+    });
+    return {
+        html: () => print(out),
+        firstElement: () => out.childNodes.find((n) => n instanceof OutElement) ??
+            null,
+    };
+}
+/**
+ * The HTML a copy offers other applications — prosemirror-view's
+ * `serializeForClipboard`, printed rather than put in a DOM: the content
+ * through `serializer`, wrapped in a table when it starts with a table's
+ * parts (a cell alone is not HTML any reader keeps), and ProseMirror's
+ * `data-pm-slice` marker on the first element, so a ProseMirror editor
+ * anywhere — this one, or one in a browser — pastes it back with its open
+ * sides and its context intact.
+ */
+export function clipboardHTML(serializer, content, openStart, openEnd, context) {
+    const out = serializer.serializeFragment(content, {
+        document: OUT_DOCUMENT,
+    });
+    let top = out.childNodes;
+    let wrappers = 0;
+    let first = top[0];
+    let needs;
+    if (first instanceof OutElement && (needs = WRAP_MAP[first.tagName])) {
+        for (let i = needs.length - 1; i >= 0; i--) {
+            const wrapper = new OutElement(needs[i]);
+            wrapper.childNodes.push(...top);
+            top = [wrapper];
+            wrappers++;
+        }
+        first = top[0];
+    }
+    if (first instanceof OutElement) {
+        first.setAttribute('data-pm-slice', `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ''} ${JSON.stringify(context)}`);
+    }
+    return top.map(print).join('');
+}
+/** A document or a fragment as HTML, through the schema's `toDOM`. */
+export function htmlFromContent(schema, content) {
+    const fragment = content instanceof Fragment ? content : content.content;
+    return renderFragment(schema, fragment).html();
+}
+//# sourceMappingURL=html.js.map