smartrte-react 0.3.5 → 1.0.0-beta.2

package/dist/test-harness/legacyClipboardEngine.js

@@ -1,67 +0,0 @@
-export function legacyCleanPastedHtml(html, options = {}, ownerDocument = document) {
-    const shouldPreserveColors = options.preserveColors ?? false;
-    const shouldPreserveDocumentLayout = options.preserveDocumentLayout ?? false;
-    const template = ownerDocument.createElement("template");
-    template.innerHTML = html
-        .replace(/ /gi, " ")
-        .replace(/\u00a0/g, " ")
-        .replace(/[\u200b\u200c\u200d]/g, "");
-    template.content.querySelectorAll("meta, link, style, script").forEach((node) => node.remove());
-    const allowedStyleNames = new Set([
-        "font-weight", "font-style", "text-decoration", "text-align", "vertical-align",
-        "border", "border-top", "border-right", "border-bottom", "border-left",
-        "border-collapse", "padding", "padding-top", "padding-right", "padding-bottom",
-        "padding-left", "list-style-type", "white-space",
-    ]);
-    if (options.preserveFontFamily)
-        allowedStyleNames.add("font-family");
-    if (shouldPreserveColors) {
-        allowedStyleNames.add("color");
-        allowedStyleNames.add("background");
-        allowedStyleNames.add("background-color");
-    }
-    if (shouldPreserveDocumentLayout) {
-        [
-            "font-size", "line-height", "margin", "margin-top", "margin-right", "margin-bottom",
-            "margin-left", "text-indent", "width", "min-width",
-        ].forEach((name) => allowedStyleNames.add(name));
-    }
-    template.content.querySelectorAll("*").forEach((node) => {
-        const className = node.getAttribute("class");
-        if (className !== "srte-preserve-colors")
-            node.removeAttribute("class");
-        node.removeAttribute("id");
-        if (!shouldPreserveDocumentLayout) {
-            node.removeAttribute("width");
-            node.removeAttribute("height");
-        }
-        const style = node.getAttribute("style");
-        if (!style)
-            return;
-        const safeRules = style
-            .split(";")
-            .map((rule) => rule.trim())
-            .filter(Boolean)
-            .filter((rule) => {
-            const separator = rule.indexOf(":");
-            if (separator === -1)
-                return false;
-            const name = rule.slice(0, separator).trim().toLowerCase();
-            const value = rule.slice(separator + 1).trim().toLowerCase();
-            if (!allowedStyleNames.has(name))
-                return false;
-            if (value.includes("position") || value.includes("expression") || value.includes("javascript:"))
-                return false;
-            if (name === "white-space" && value !== "pre-wrap")
-                return false;
-            if ((name === "width" || name === "min-width") && !/^[\d.]+(px|pt|em|rem|%)$/.test(value))
-                return false;
-            return true;
-        });
-        if (safeRules.length)
-            node.setAttribute("style", safeRules.join("; "));
-        else
-            node.removeAttribute("style");
-    });
-    return template.innerHTML;
-}

package/dist/test-harness/legacyInlineEngine.d.ts

@@ -1,19 +0,0 @@
-/**
- * Test-only Phase 4 snapshot of the legacy inline command engine.
- *
- * This file was created before production inline handlers are removed. It must
- * never be imported by product code. The shadow corpus keeps it so comparison
- * remains possible after ClassicEditor routes exclusively to foundation marks.
- */
-import { type SmartEditorState } from "smartrte-core/legacy";
-export type LegacyInlineToolId = "bold" | "italic" | "underline" | "strike" | "code" | "superscript" | "subscript" | "textColor" | "backgroundColor" | "fontSize" | "fontFamily" | "link";
-export declare const legacyInlineToolIds: readonly LegacyInlineToolId[];
-export interface LegacyInlineResult {
-    readonly html: string;
-    readonly selection: SmartEditorState["selection"];
-}
-export declare const runLegacyInlineTool: (root: HTMLElement, tool: LegacyInlineToolId, input?: unknown) => LegacyInlineResult | null;
-export declare const runLegacyLinkAction: (root: HTMLElement, action: "apply" | "edit" | "remove", input?: {
-    href: string;
-    target?: string;
-}) => LegacyInlineResult | null;

package/dist/test-harness/legacyInlineEngine.js

@@ -1,49 +0,0 @@
-/**
- * Test-only Phase 4 snapshot of the legacy inline command engine.
- *
- * This file was created before production inline handlers are removed. It must
- * never be imported by product code. The shadow corpus keeps it so comparison
- * remains possible after ClassicEditor routes exclusively to foundation marks.
- */
-import { applyBackgroundColor, applyFontFamily, applyFontSize, applyLink, applyTextColor, applyTransaction, removeLink, toggleBold, toggleInlineCode, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline, updateLink, } from "smartrte-core/legacy";
-import { selectionFromDom } from "../adapters/domSelectionBridge.js";
-import { serializeSmartDocument, smartDocumentFromEditorRoot } from "../adapters/domSmartDocument.js";
-const commands = Object.freeze({
-    bold: toggleBold,
-    italic: toggleItalic,
-    underline: toggleUnderline,
-    strike: toggleStrike,
-    code: toggleInlineCode,
-    superscript: toggleSuperscript,
-    subscript: toggleSubscript,
-    textColor: applyTextColor,
-    backgroundColor: applyBackgroundColor,
-    fontSize: applyFontSize,
-    fontFamily: applyFontFamily,
-    link: applyLink,
-});
-export const legacyInlineToolIds = Object.freeze(Object.keys(commands));
-export const runLegacyInlineTool = (root, tool, input) => {
-    const selection = selectionFromDom(root, root.ownerDocument.getSelection());
-    if (!selection)
-        return null;
-    const { document } = smartDocumentFromEditorRoot(root);
-    const state = { document, selection };
-    const command = commands[tool];
-    if (!command.isEnabled(state, input))
-        return null;
-    const next = applyTransaction(state, command.execute(state, input));
-    return { html: serializeSmartDocument(next.document), selection: next.selection };
-};
-export const runLegacyLinkAction = (root, action, input) => {
-    const selection = selectionFromDom(root, root.ownerDocument.getSelection());
-    if (!selection)
-        return null;
-    const { document } = smartDocumentFromEditorRoot(root);
-    const state = { document, selection };
-    const command = action === "remove" ? removeLink : action === "edit" ? updateLink : applyLink;
-    if (!command.isEnabled(state, input))
-        return null;
-    const next = applyTransaction(state, command.execute(state, input));
-    return { html: serializeSmartDocument(next.document), selection: next.selection };
-};

package/dist/test-harness/legacyTableEngine.d.ts

@@ -1,12 +0,0 @@
-/**
- * Test-only snapshot of the pre-Phase-6 table engine entry point. Keep this
- * isolated from product imports so shadow comparison remains possible after
- * ClassicEditor switches to the foundation table commands.
- */
-export interface LegacyTableIntent {
-    readonly id: string;
-    readonly input?: Readonly<Record<string, unknown>>;
-}
-export declare const executeRetainedLegacyTable: (html: string, intent: LegacyTableIntent, ownerDocument?: Document) => string | null;
-/** Retained snapshot for the block-level table insertion command. */
-export declare const executeRetainedLegacyTableInsert: (html: string, rows: number, columns: number, headerRow?: boolean, ownerDocument?: Document) => string | null;

package/dist/test-harness/legacyTableEngine.js

@@ -1,25 +0,0 @@
-import { createSmartEditor, tablePlugin } from "smartrte-core/legacy";
-import { serializeSmartDocument, smartDocumentFromHtml } from "../adapters/domSmartDocument.js";
-export const executeRetainedLegacyTable = (html, intent, ownerDocument = document) => {
-    const model = smartDocumentFromHtml(html, ownerDocument);
-    if (model.children.length !== 1 || model.children[0].type !== "table")
-        return null;
-    const editor = createSmartEditor({
-        state: { document: model, selection: { type: "node", path: [0] } },
-        plugins: [tablePlugin],
-    });
-    if (!editor.execute(intent.id, { ...(intent.input || {}), tablePath: [0] }))
-        return null;
-    return serializeSmartDocument(editor.state.document);
-};
-/** Retained snapshot for the block-level table insertion command. */
-export const executeRetainedLegacyTableInsert = (html, rows, columns, headerRow = false, ownerDocument = document) => {
-    const model = smartDocumentFromHtml(html, ownerDocument);
-    const editor = createSmartEditor({
-        state: { document: model, selection: { type: "text", anchor: { path: [0, 0], offset: 0 }, focus: { path: [0, 0], offset: 0 } } },
-        plugins: [tablePlugin],
-    });
-    if (!editor.execute("table.insert", { path: [1], rows, columns, headerRow }))
-        return null;
-    return serializeSmartDocument(editor.state.document);
-};

package/dist/test-harness/tableShadowComparator.d.ts

@@ -1,29 +0,0 @@
-import { type DomTableCommand } from "../adapters/domTableCommandBridge.js";
-export type TableShadowDivergence = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
-export interface TableShadowResult {
-    readonly equivalent: boolean;
-    readonly classification?: TableShadowDivergence;
-    readonly legacyStructureHash: string;
-    readonly canonicalStructureHash: string;
-    readonly selectionCompared?: boolean;
-    readonly selectionEquivalent?: boolean;
-    readonly legacySelectionHash?: string;
-    readonly canonicalSelectionHash?: string;
-}
-export declare const compareRetainedAndCanonicalTable: (html: string, command: DomTableCommand) => TableShadowResult;
-/**
- * Compares the retained block-level table insertion command with the
- * canonical insertion path.  The insertion caret is a stable semantic point:
- * the first paragraph in the first inserted cell.  This is intentionally
- * separate from the cell-editing comparator above, whose old command surface
- * did not expose a selection result.
- */
-export declare const compareRetainedAndCanonicalTableInsert: (html: string, rows?: number, columns?: number, headerRow?: boolean) => TableShadowResult;
-/** Hash-only comparator record. Document text and HTML are deliberately excluded. */
-export declare const tableShadowLogRecord: (scenarioId: string, result: TableShadowResult) => {
-    classification?: TableShadowDivergence;
-    scenarioId: string;
-    equivalent: boolean;
-    legacyStructureHash: string;
-    canonicalStructureHash: string;
-};

package/dist/test-harness/tableShadowComparator.js

@@ -1,101 +0,0 @@
-import { compareShadowDocuments, foundationSchema, isTextNode, normalizedStructureWithoutIds, parseCanonicalTableHtml } from "smartrte-core/foundation";
-import { executeDomTableCommand, executeDomTableInsert, executeDomTableRemoval } from "../adapters/domTableCommandBridge.js";
-import { executeRetainedLegacyTable, executeRetainedLegacyTableInsert } from "./legacyTableEngine.js";
-const hash = (value) => {
-    const input = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
-    let state = 2166136261;
-    for (let index = 0; index < input.length; index += 1) {
-        state ^= input.charCodeAt(index);
-        state = Math.imul(state, 16777619);
-    }
-    return (state >>> 0).toString(16).padStart(8, "0");
-};
-const documentText = (node) => isTextNode(node) ? node.text : (node.children || []).map(documentText).join("");
-export const compareRetainedAndCanonicalTable = (html, command) => {
-    const legacyHtml = executeRetainedLegacyTable(html, command);
-    const host = document.createElement("div");
-    host.innerHTML = html;
-    const canonicalTable = host.querySelector("table");
-    if (command.id === "table.remove") {
-        const legacyDocument = parseCanonicalTableHtml(legacyHtml || "");
-        const removed = canonicalTable instanceof HTMLTableElement && executeDomTableRemoval(canonicalTable);
-        const canonicalDocument = parseCanonicalTableHtml(host.innerHTML);
-        const legacy = normalizedStructureWithoutIds(legacyDocument, foundationSchema);
-        const current = normalizedStructureWithoutIds(canonicalDocument, foundationSchema);
-        const equivalent = removed && JSON.stringify(legacy) === JSON.stringify(current);
-        return {
-            equivalent,
-            legacyStructureHash: hash(legacy), canonicalStructureHash: hash(current),
-            ...(!equivalent ? { classification: "semantic" } : {}),
-        };
-    }
-    const canonical = canonicalTable instanceof HTMLTableElement ? executeDomTableCommand(canonicalTable, command) : null;
-    if (!legacyHtml || !canonical)
-        return { equivalent: false, classification: "semantic", legacyStructureHash: hash(legacyHtml), canonicalStructureHash: hash(canonical?.outerHTML) };
-    const legacyDocument = parseCanonicalTableHtml(legacyHtml);
-    const canonicalDocument = parseCanonicalTableHtml(canonical.outerHTML);
-    const legacy = normalizedStructureWithoutIds(legacyDocument, foundationSchema);
-    const current = normalizedStructureWithoutIds(canonicalDocument, foundationSchema);
-    const equivalent = JSON.stringify(legacy) === JSON.stringify(current);
-    const dataLoss = documentText(canonicalDocument) !== documentText(legacyDocument);
-    const intentional = command.id === "table.header.row.toggle" || command.id === "table.header.column.toggle" || command.id === "table.header.cell.toggle"
-        ? "visual-only" : "expected-normalization";
-    return {
-        equivalent, legacyStructureHash: hash(legacy), canonicalStructureHash: hash(current),
-        ...(!equivalent ? { classification: dataLoss ? "data-loss" : intentional } : {}),
-    };
-};
-/**
- * Compares the retained block-level table insertion command with the
- * canonical insertion path.  The insertion caret is a stable semantic point:
- * the first paragraph in the first inserted cell.  This is intentionally
- * separate from the cell-editing comparator above, whose old command surface
- * did not expose a selection result.
- */
-export const compareRetainedAndCanonicalTableInsert = (html, rows = 2, columns = 2, headerRow = false) => {
-    const legacyHtml = executeRetainedLegacyTableInsert(html, rows, columns, headerRow);
-    const host = document.createElement("div");
-    host.innerHTML = html;
-    const canonicalTable = executeDomTableInsert(host, 0, rows, columns, headerRow);
-    if (!legacyHtml || !canonicalTable)
-        return {
-            equivalent: false,
-            classification: "semantic",
-            legacyStructureHash: hash(legacyHtml),
-            canonicalStructureHash: hash(host.innerHTML),
-            selectionCompared: true,
-            selectionEquivalent: false,
-        };
-    const legacyDocument = parseCanonicalTableHtml(legacyHtml);
-    const canonicalDocument = parseCanonicalTableHtml(host.innerHTML);
-    const selection = {
-        type: "text",
-        anchor: { path: [1, 0, 0, 0], offset: 0 },
-        head: { path: [1, 0, 0, 0], offset: 0 },
-    };
-    const comparison = compareShadowDocuments({
-        legacyDocument,
-        legacySelection: selection,
-        canonicalDocument,
-        canonicalSelection: selection,
-        schema: foundationSchema,
-    });
-    const insertionDataLoss = documentText(legacyDocument) !== documentText(canonicalDocument);
-    return {
-        equivalent: comparison.equivalent,
-        ...(!comparison.documentEquivalent
-            ? { classification: insertionDataLoss ? "data-loss" : "expected-normalization" }
-            : comparison.classification ? { classification: comparison.classification } : {}),
-        legacyStructureHash: comparison.legacyStructureHash,
-        canonicalStructureHash: comparison.canonicalStructureHash,
-        selectionCompared: true,
-        selectionEquivalent: comparison.selectionEquivalent,
-        legacySelectionHash: comparison.legacySelectionHash,
-        canonicalSelectionHash: comparison.canonicalSelectionHash,
-    };
-};
-/** Hash-only comparator record. Document text and HTML are deliberately excluded. */
-export const tableShadowLogRecord = (scenarioId, result) => ({
-    scenarioId, equivalent: result.equivalent, legacyStructureHash: result.legacyStructureHash,
-    canonicalStructureHash: result.canonicalStructureHash, ...(result.classification ? { classification: result.classification } : {}),
-});