smartrte-react 0.3.5 → 1.0.0-beta.2

package/dist/adapters/domTableCommandBridge.d.ts

@@ -1,35 +1,61 @@
-import { type MergeTableCellsInput, type SetTableCellStyleInput, type SetTableColumnWidthInput, type SetTableRowHeightInput, type TableHeaderInput, type SplitTableCellInput, type TableColumnInput, type TableRowInput, type ToggleTableCellBorderInput } from "smartrte-core";
+type Point = {
+    row: number;
+    column: number;
+};
 export type DomTableCommand = {
+    id: "table.remove";
+    input?: Record<string, never>;
+} | {
     id: "table.row.add" | "table.row.remove";
-    input: Omit<TableRowInput, "tablePath">;
+    input: {
+        index: number;
+    };
 } | {
     id: "table.column.add" | "table.column.remove";
-    input: Omit<TableColumnInput, "tablePath">;
+    input: {
+        index: number;
+    };
 } | {
     id: "table.cell.merge";
-    input: Omit<MergeTableCellsInput, "tablePath">;
+    input: {
+        start: Point;
+        end: Point;
+    };
 } | {
     id: "table.cell.split";
-    input: Omit<SplitTableCellInput, "tablePath">;
+    input: Point;
 } | {
     id: "table.header.cell.toggle" | "table.header.row.toggle" | "table.header.column.toggle";
-    input: Omit<TableHeaderInput, "tablePath">;
+    input: Point;
 } | {
     id: "table.cell.style.set";
-    input: Omit<SetTableCellStyleInput, "tablePath">;
+    input: {
+        start: Point;
+        end?: Point;
+        backgroundColor?: string | null;
+        textColor?: string | null;
+    };
 } | {
     id: "table.column.width.set";
-    input: Omit<SetTableColumnWidthInput, "tablePath">;
+    input: {
+        index: number;
+        widthPx: number;
+    };
 } | {
     id: "table.row.height.set";
-    input: Omit<SetTableRowHeightInput, "tablePath">;
+    input: {
+        index: number;
+        heightPx: number;
+    };
 } | {
     id: "table.cell.border.toggle";
-    input: Omit<ToggleTableCellBorderInput, "tablePath">;
+    input: {
+        start: Point;
+        end?: Point;
+        visibleBorder?: string;
+    };
 };
-/**
- * Executes a core table command while replacing only the affected table.
- * Visual table/cell attributes are transferred by logical grid position.
- */
-export declare const executeDomTableCommand: (table: HTMLTableElement, command: DomTableCommand) => HTMLTableElement | null;
-export declare const executeDomTableRemoval: (table: HTMLTableElement) => boolean;
+export declare const executeDomTableCommand: (element: HTMLTableElement, command: DomTableCommand) => HTMLTableElement | null;
+export declare const executeDomTableRemoval: (element: HTMLTableElement) => boolean;
+export declare const executeDomTableInsert: (root: HTMLElement, afterBlockIndex: number, rows: number, columns: number, withHeader?: boolean) => HTMLTableElement | null;
+export {};

package/dist/adapters/domTableCommandBridge.js

@@ -1,201 +1,231 @@
-import { createSmartEditor, tablePlugin, } from "smartrte-core";
-import { serializeSmartDocument, smartDocumentFromHtml } from "./domSmartDocument.js";
-const cellsOf = (row) => Array.from(row.children).filter((node) => node instanceof HTMLTableCellElement);
-const cellGrid = (table) => {
-    const rows = Array.from(table.rows);
-    const grid = [];
-    rows.forEach((row, rowIndex) => {
-        grid[rowIndex] || (grid[rowIndex] = []);
+import { applyOperations, createNodeId, createScopeIndex, foundationSchema, insertTableColumnCommand, insertTableCommand, insertTableRowCommand, mergeTableCellsCommand, occupancyGridFor, parseCanonicalTableHtml, removeTableColumnCommand, removeTableRowCommand, removeTableCommand, repair, serializeCanonicalTableHtml, setTableCellAttributesCommand, setTableColumnWidthCommand, setTableHeaderCommand, setTableRowHeightCommand, splitTableCellCommand, } from "smartrte-core/foundation";
+const canonicalTable = (element) => {
+    const repaired = repair(parseCanonicalTableHtml(element.outerHTML)).doc;
+    const table = repaired.children[0];
+    return table && table.type === "table" ? { document: repaired, table: table } : null;
+};
+const tableScope = (table, start, end = start) => {
+    const grid = occupancyGridFor(table);
+    const top = Math.max(0, Math.min(start.row, end.row));
+    const bottom = Math.min(grid.rows - 1, Math.max(start.row, end.row));
+    const left = Math.max(0, Math.min(start.column, end.column));
+    const right = Math.min(grid.columns - 1, Math.max(start.column, end.column));
+    const exclusive = { top, left, bottom: bottom + 1, right: right + 1 };
+    return {
+        kind: "table-grid", tableId: table.id, rect: { top, left, bottom, right },
+        cellIds: grid.anchors.filter((cell) => cell.top <= bottom && cell.bottom > top && cell.left <= right && cell.right > left).map((cell) => cell.cellId),
+        coveredCellIds: grid.coveredIn(exclusive).map((cell) => cell.cellId),
+        rectangular: grid.isRectangular(exclusive), range: { from: { path: [0], offset: 0 }, to: { path: [0], offset: 1 } },
+        isolatingAncestorId: null, clamped: false,
+    };
+};
+const commandContext = (document) => ({ schema: foundationSchema, positions: createScopeIndex().positions(document, foundationSchema) });
+const generated = (count, prefix) => Array.from({ length: count }, () => `${prefix}-${createNodeId()}`);
+const domGrid = (table) => {
+    const slots = [];
+    Array.from(table.rows).forEach((row, rowIndex) => {
+        slots[rowIndex] || (slots[rowIndex] = []);
         let column = 0;
-        cellsOf(row).forEach((cell) => {
-            var _a;
-            while (grid[rowIndex][column])
+        Array.from(row.cells).forEach((cell) => {
+            while (slots[rowIndex][column])
                 column += 1;
-            const rowspan = Math.max(1, cell.rowSpan || 1);
-            const colspan = Math.max(1, cell.colSpan || 1);
-            for (let rowOffset = 0; rowOffset < rowspan; rowOffset += 1) {
-                grid[_a = rowIndex + rowOffset] || (grid[_a] = []);
-                for (let columnOffset = 0; columnOffset < colspan; columnOffset += 1) {
-                    grid[rowIndex + rowOffset][column + columnOffset] = cell;
-                }
+            for (let r = rowIndex; r < rowIndex + Math.max(1, cell.rowSpan); r += 1) {
+                slots[r] || (slots[r] = []);
+                for (let c = column; c < column + Math.max(1, cell.colSpan); c += 1)
+                    slots[r][c] = cell;
             }
-            column += colspan;
+            column += Math.max(1, cell.colSpan);
         });
     });
-    return grid;
+    return slots;
 };
 const copyVisualAttributes = (from, to) => {
-    const style = from.getAttribute("style");
-    const className = from.getAttribute("class");
-    if (style)
-        to.setAttribute("style", style);
-    if (className)
-        to.setAttribute("class", className);
-};
-const reconcileHeaderStyle = (from, to) => {
-    if (from.tagName === to.tagName)
-        return;
-    if (to.tagName === "TH") {
-        to.style.fontWeight = "700";
-        to.style.background = to.style.background || "#f3f4f6";
-        to.style.textAlign = to.style.textAlign || "left";
-        return;
-    }
-    if (to.style.fontWeight === "700" || to.style.fontWeight === "bold")
-        to.style.fontWeight = "";
-    if (to.style.background === "rgb(243, 244, 246)" || to.style.background === "#f3f4f6") {
-        to.style.background = "";
-    }
+    if (from.className)
+        to.className = from.className;
+    const retained = from.getAttribute("style");
+    if (retained)
+        for (const declaration of retained.split(";")) {
+            const separator = declaration.indexOf(":");
+            if (separator > 0)
+                to.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+        }
 };
-/**
- * Executes a core table command while replacing only the affected table.
- * Visual table/cell attributes are transferred by logical grid position.
- */
-export const executeDomTableCommand = (table, command) => {
-    const document = smartDocumentFromHtml(table.outerHTML, table.ownerDocument);
-    if (document.children.length !== 1 || document.children[0].type !== "table")
-        return null;
-    const editor = createSmartEditor({
-        state: { document, selection: { type: "node", path: [0] } },
-        plugins: [tablePlugin],
-    });
-    if (!editor.execute(command.id, { ...command.input, tablePath: [0] }))
-        return null;
-    if (command.id === "table.column.width.set") {
-        let group = table.querySelector(":scope > colgroup");
+const projectAttributesInPlace = (element, after) => {
+    const table = after.children[0];
+    const modelGrid = occupancyGridFor(table);
+    const grid = domGrid(element);
+    const widths = Array.isArray(table.attrs?.columnWidths) ? table.attrs.columnWidths : [];
+    if (widths.length) {
+        let group = element.querySelector(":scope > colgroup");
         if (!group) {
-            group = table.ownerDocument.createElement("colgroup");
-            table.insertBefore(group, table.firstChild);
-        }
-        const logicalWidth = Math.max(...cellGrid(table).map((row) => row.length));
-        while (group.children.length < logicalWidth) {
-            group.appendChild(table.ownerDocument.createElement("col"));
-        }
-        const column = group.children[command.input.index];
-        if (!column)
-            return null;
-        column.style.width = `${command.input.widthPx}px`;
-        const seen = new Set();
-        cellGrid(table).forEach((row) => {
-            const target = row[command.input.index];
-            if (!target || seen.has(target))
-                return;
-            seen.add(target);
-            target.style.width = `${command.input.widthPx}px`;
-            target.style.minWidth = `${command.input.widthPx}px`;
-            target.style.maxWidth = `${command.input.widthPx}px`;
-        });
-        return table;
-    }
-    if (command.id === "table.row.height.set") {
-        const row = table.rows[command.input.index];
-        if (!row)
-            return null;
-        row.style.height = `${command.input.heightPx}px`;
-        cellsOf(row).forEach((target) => {
-            target.style.height = `${command.input.heightPx}px`;
-        });
-        return table;
-    }
-    if (command.id === "table.cell.style.set") {
-        const end = command.input.end || command.input.start;
-        const top = Math.min(command.input.start.row, end.row);
-        const bottom = Math.max(command.input.start.row, end.row);
-        const left = Math.min(command.input.start.column, end.column);
-        const right = Math.max(command.input.start.column, end.column);
-        const grid = cellGrid(table);
-        const targets = new Set();
-        for (let row = top; row <= bottom; row += 1) {
-            for (let column = left; column <= right; column += 1) {
-                const target = grid[row]?.[column];
-                if (target)
-                    targets.add(target);
-            }
+            group = element.ownerDocument.createElement("colgroup");
+            element.prepend(group);
         }
-        targets.forEach((target) => {
-            if (command.input.backgroundColor !== undefined) {
-                target.style.backgroundColor = command.input.backgroundColor || "";
-            }
-            if (command.input.textColor !== undefined) {
-                target.style.color = command.input.textColor || "";
-            }
-        });
-        return table;
+        while (group.children.length < widths.length)
+            group.appendChild(element.ownerDocument.createElement("col"));
+        while (group.children.length > widths.length)
+            group.lastElementChild?.remove();
+        widths.forEach((width, index) => { group.children[index].style.width = `${width}px`; });
     }
-    if (command.id === "table.cell.border.toggle") {
-        const end = command.input.end || command.input.start;
-        const top = Math.min(command.input.start.row, end.row);
-        const bottom = Math.max(command.input.start.row, end.row);
-        const left = Math.min(command.input.start.column, end.column);
-        const right = Math.max(command.input.start.column, end.column);
-        const grid = cellGrid(table);
-        const targets = new Set();
-        for (let row = top; row <= bottom; row += 1) {
-            for (let column = left; column <= right; column += 1) {
-                const target = grid[row]?.[column];
-                if (target)
-                    targets.add(target);
-            }
+    (table.children || []).forEach((row, rowIndex) => {
+        if (row.type !== "table_row")
+            return;
+        const height = Number(row.attrs?.height);
+        if (Number.isFinite(height) && height > 0)
+            element.rows[rowIndex].style.height = `${height}px`;
+    });
+    modelGrid.anchors.forEach((cell) => {
+        const target = grid[cell.top]?.[cell.left];
+        if (!target)
+            return;
+        target.style.background = cell.node.attrs?.background ? String(cell.node.attrs.background) : "";
+        target.style.color = cell.node.attrs?.textColor ? String(cell.node.attrs.textColor) : "";
+        target.style.border = cell.node.attrs?.borders ? String(cell.node.attrs.borders) : "";
+        target.style.verticalAlign = cell.node.attrs?.verticalAlign ? String(cell.node.attrs.verticalAlign) : "";
+        if (widths.length) {
+            const width = widths.slice(cell.left, cell.right).reduce((sum, value) => sum + value, 0);
+            target.style.width = `${width}px`;
+            target.style.minWidth = `${width}px`;
+            target.style.maxWidth = `${width}px`;
         }
-        targets.forEach((target) => {
-            target.style.border = target.style.border && target.style.border !== "none"
-                ? "none"
-                : command.input.visibleBorder || "1px solid #d1d5db";
-        });
-        return table;
-    }
+        const rowHeight = Number(table.children?.[cell.top]?.attrs?.height);
+        if (Number.isFinite(rowHeight) && rowHeight > 0)
+            target.style.height = `${rowHeight}px`;
+    });
+    return element;
+};
+const replaceDomTable = (table, document) => {
     const container = table.ownerDocument.createElement("div");
-    container.innerHTML = serializeSmartDocument(editor.state.document);
+    container.innerHTML = serializeCanonicalTableHtml(document, { fragment: true });
     const replacement = container.querySelector("table");
     if (!(replacement instanceof HTMLTableElement))
         return null;
     copyVisualAttributes(table, replacement);
-    const previousGrid = cellGrid(table);
-    const nextGrid = cellGrid(replacement);
-    const previousPosition = (row, column) => {
-        if (command.id === "table.row.add") {
-            if (row === command.input.index)
-                return null;
-            return { row: row > command.input.index ? row - 1 : row, column };
-        }
-        if (command.id === "table.row.remove") {
-            return { row: row >= command.input.index ? row + 1 : row, column };
-        }
-        if (command.id === "table.column.add") {
-            if (column === command.input.index)
-                return null;
-            return { row, column: column > command.input.index ? column - 1 : column };
-        }
-        if (command.id === "table.column.remove") {
-            return { row, column: column >= command.input.index ? column + 1 : column };
-        }
-        return { row, column };
-    };
+    const beforeGrid = domGrid(table);
+    const afterGrid = domGrid(replacement);
     const copied = new Set();
-    nextGrid.forEach((row, rowIndex) => row.forEach((nextCell, column) => {
-        if (!nextCell || copied.has(nextCell))
+    afterGrid.forEach((row, rowIndex) => row.forEach((cell, column) => {
+        if (!cell || copied.has(cell))
             return;
-        const position = previousPosition(rowIndex, column);
-        const previousCell = position ? previousGrid[position.row]?.[position.column] : undefined;
-        if (previousCell) {
-            copyVisualAttributes(previousCell, nextCell);
-            reconcileHeaderStyle(previousCell, nextCell);
+        const source = beforeGrid[rowIndex]?.[column];
+        if (source)
+            copyVisualAttributes(source, cell);
+        if (cell.tagName === "TH" && source?.tagName !== "TH") {
+            cell.style.fontWeight = "700";
+            cell.style.background = cell.style.background || "#f3f4f6";
+            cell.style.textAlign = cell.style.textAlign || "left";
+        }
+        else if (cell.tagName === "TD" && source?.tagName === "TH") {
+            if (["700", "bold"].includes(cell.style.fontWeight))
+                cell.style.fontWeight = "";
+            if (["rgb(243, 244, 246)", "#f3f4f6"].includes(cell.style.background))
+                cell.style.background = "";
+            if (cell.style.textAlign === "left")
+                cell.style.textAlign = "";
         }
-        copied.add(nextCell);
+        copied.add(cell);
     }));
     table.replaceWith(replacement);
     return replacement;
 };
-export const executeDomTableRemoval = (table) => {
-    const document = smartDocumentFromHtml(table.outerHTML, table.ownerDocument);
-    if (document.children.length !== 1 || document.children[0].type !== "table")
+export const executeDomTableCommand = (element, command) => {
+    if (command.id === "table.remove")
+        return null;
+    const parsed = canonicalTable(element);
+    if (!parsed)
+        return null;
+    const { document, table } = parsed;
+    const grid = occupancyGridFor(table);
+    const start = "start" in command.input ? command.input.start : "row" in command.input ? command.input : { row: "index" in command.input ? command.input.index : 0, column: 0 };
+    const end = "end" in command.input && command.input.end ? command.input.end : start;
+    const scope = tableScope(table, start, end);
+    const ctx = commandContext(document);
+    let operations = [];
+    if (command.id === "table.row.add")
+        operations = insertTableRowCommand(document, scope, {
+            rowIndex: command.input.index, rowId: `row-${createNodeId()}`,
+            cellIds: generated(grid.columns, "cell"), paragraphIds: generated(grid.columns, "paragraph"),
+        }, ctx);
+    else if (command.id === "table.row.remove")
+        operations = removeTableRowCommand(document, scope, { rowIndex: command.input.index }, ctx);
+    else if (command.id === "table.column.add")
+        operations = insertTableColumnCommand(document, scope, {
+            columnIndex: command.input.index, cellIds: generated(grid.rows, "cell"), paragraphIds: generated(grid.rows, "paragraph"),
+        }, ctx);
+    else if (command.id === "table.column.remove")
+        operations = removeTableColumnCommand(document, scope, { columnIndex: command.input.index }, ctx);
+    else if (command.id === "table.cell.merge")
+        operations = mergeTableCellsCommand(document, scope, {}, ctx);
+    else if (command.id === "table.cell.split") {
+        const target = grid.at(command.input.row, command.input.column);
+        const count = target ? (target.bottom - target.top) * (target.right - target.left) - 1 : 0;
+        operations = splitTableCellCommand(document, scope, { cellIds: generated(count, "cell"), paragraphIds: generated(count, "paragraph") }, ctx);
+    }
+    else if (command.id.startsWith("table.header.")) {
+        const point = command.input;
+        const targetCells = command.id === "table.header.cell.toggle" ? [grid.at(point.row, point.column)].filter(Boolean)
+            : command.id === "table.header.row.toggle" ? grid.anchors.filter((cell) => cell.top <= point.row && cell.bottom > point.row)
+                : grid.anchors.filter((cell) => cell.left <= point.column && cell.right > point.column);
+        const makeHeader = targetCells.some((cell) => cell?.node.attrs?.header !== true);
+        if (command.id === "table.header.cell.toggle" && point.row > 0 && point.column > 0)
+            return null;
+        const headerScope = { ...scope, cellIds: targetCells.map((cell) => cell.cellId) };
+        operations = command.id === "table.header.cell.toggle"
+            ? setTableCellAttributesCommand(document, headerScope, { attrs: { header: makeHeader } }, ctx)
+            : setTableHeaderCommand(document, scope, { target: makeHeader ? command.id === "table.header.row.toggle" ? "row" : "column" : "none" }, ctx);
+    }
+    else if (command.id === "table.cell.style.set")
+        operations = setTableCellAttributesCommand(document, scope, { attrs: {
+                ...(command.input.backgroundColor !== undefined ? { background: command.input.backgroundColor || undefined } : {}),
+                ...(command.input.textColor !== undefined ? { textColor: command.input.textColor || undefined } : {}),
+            } }, ctx);
+    else if (command.id === "table.cell.border.toggle") {
+        const visible = scope.cellIds.some((id) => grid.anchors.find((cell) => cell.cellId === id)?.node.attrs?.borders && grid.anchors.find((cell) => cell.cellId === id)?.node.attrs?.borders !== "none");
+        operations = setTableCellAttributesCommand(document, scope, { attrs: { borders: visible ? "none" : command.input.visibleBorder || "1px solid #d1d5db" } }, ctx);
+    }
+    else if (command.id === "table.column.width.set")
+        operations = setTableColumnWidthCommand(document, scope, { index: command.input.index, width: command.input.widthPx }, ctx);
+    else if (command.id === "table.row.height.set")
+        operations = setTableRowHeightCommand(document, scope, { index: command.input.index, height: command.input.heightPx }, ctx);
+    if (!operations.length)
+        return null;
+    const after = applyOperations(document, operations);
+    if (["table.cell.style.set", "table.cell.border.toggle", "table.column.width.set", "table.row.height.set"].includes(command.id)) {
+        return projectAttributesInPlace(element, after);
+    }
+    return replaceDomTable(element, after);
+};
+export const executeDomTableRemoval = (element) => {
+    const parsed = canonicalTable(element);
+    if (!parsed)
         return false;
-    const editor = createSmartEditor({
-        state: { document, selection: { type: "node", path: [0] } },
-        plugins: [tablePlugin],
-    });
-    if (!editor.execute("table.remove", { tablePath: [0] }))
+    const scope = tableScope(parsed.table, { row: 0, column: 0 });
+    if (!removeTableCommand(parsed.document, scope, {}, commandContext(parsed.document)).length)
         return false;
-    table.remove();
+    element.remove();
     return true;
 };
+export const executeDomTableInsert = (root, afterBlockIndex, rows, columns, withHeader = false) => {
+    if (rows < 1 || columns < 1)
+        return null;
+    const document = repair(parseCanonicalTableHtml(root.innerHTML)).doc;
+    const index = Math.max(0, Math.min(afterBlockIndex, document.children.length - 1));
+    const target = document.children[index];
+    if (!target || !("id" in target))
+        return null;
+    const blockScope = {
+        kind: "block-range", blockIds: [target.id], promotedFromPartial: false,
+        commonParentId: document.id, range: { from: { path: [], offset: index }, to: { path: [], offset: index + 1 } },
+        isolatingAncestorId: null, clamped: false,
+    };
+    const total = rows * columns;
+    const tableId = `table-${createNodeId()}`;
+    const operations = insertTableCommand(document, blockScope, {
+        rows, columns, withHeader, placement: "after",
+        ids: { tableId, rowIds: generated(rows, "row"), cellIds: generated(total, "cell"), paragraphIds: generated(total, "paragraph") },
+    }, commandContext(document));
+    if (!operations.length)
+        return null;
+    root.innerHTML = serializeCanonicalTableHtml(applyOperations(document, operations), { fragment: true });
+    return root.querySelector(`table[data-smart-id="${tableId}"]`);
+};

package/dist/adapters/internalFlags.d.ts

@@ -1,13 +1,5 @@
-import type { CoreInlineMark } from "./inlineMarkCoreExecution.js";
 export interface SmartRteInternalFlags {
-    coreBold?: boolean;
-    coreItalic?: boolean;
-    coreUnderline?: boolean;
-    coreSuperscript?: boolean;
-    coreSubscript?: boolean;
-    coreInlineMarks?: boolean;
     shadowMode?: boolean;
 }
 export declare const getSmartRteInternalFlags: () => SmartRteInternalFlags;
-export declare const isCoreInlineMarkFlagEnabled: (mark: CoreInlineMark) => boolean;
 export declare const isShadowModeFlagEnabled: () => boolean;

package/dist/adapters/internalFlags.js

@@ -1,30 +1,6 @@
-const markFlagNames = {
-    bold: "coreBold",
-    italic: "coreItalic",
-    underline: "coreUnderline",
-    superscript: "coreSuperscript",
-    subscript: "coreSubscript",
-};
-const legacyMarkFlagNames = {
-    bold: "__SMART_RTE_CORE_BOLD__",
-    italic: "__SMART_RTE_CORE_ITALIC__",
-    underline: "__SMART_RTE_CORE_UNDERLINE__",
-    superscript: "__SMART_RTE_CORE_SUPERSCRIPT__",
-    subscript: "__SMART_RTE_CORE_SUBSCRIPT__",
-};
 const getGlobal = () => globalThis;
 const readBoolean = (value) => typeof value === "boolean" ? value : undefined;
 export const getSmartRteInternalFlags = () => getGlobal().__SMART_RTE_INTERNAL_FLAGS__ || {};
-export const isCoreInlineMarkFlagEnabled = (mark) => {
-    const flags = getSmartRteInternalFlags();
-    const individual = readBoolean(flags[markFlagNames[mark]]);
-    if (individual !== undefined)
-        return individual;
-    const grouped = readBoolean(flags.coreInlineMarks);
-    if (grouped !== undefined)
-        return grouped;
-    return getGlobal()[legacyMarkFlagNames[mark]] === true;
-};
 export const isShadowModeFlagEnabled = () => {
     const configured = readBoolean(getSmartRteInternalFlags().shadowMode);
     if (configured !== undefined)

package/dist/adapters/legacyListShadowComparator.d.ts

@@ -1,4 +1,4 @@
-import { shadowLogRecord } from "smartrte-core";
+import { shadowLogRecord } from "smartrte-core/foundation";
 export interface NamedListIntentReplay {
     readonly intent: string;
     readonly equivalent: boolean;

package/dist/adapters/legacyListShadowComparator.js

@@ -1,4 +1,4 @@
-import { applyOperations, compareShadowDocuments, createTransactionMap, createList, createScopeIndex, foundationSchema, indentList, moveListItems, outdentList, setListChecked, setListPreset, setListStyle, shadowLogRecord, unwrapList, isTextNode, } from "smartrte-core";
+import { applyOperations, compareShadowDocuments, createTransactionMap, createList, createScopeIndex, foundationSchema, indentList, moveListItems, outdentList, setListChecked, setListPreset, setListStyle, shadowLogRecord, unwrapList, isTextNode, } from "smartrte-core/foundation";
 import { applyTransaction as applyLegacyTransaction, indentListItems as legacyIndentListItems, moveBlocks as legacyMoveBlocks, outdentListItems as legacyOutdentListItems, setChecklistItemChecked as legacySetChecklistItemChecked, toggleList as legacyToggleList, } from "smartrte-core/legacy";
 const p = (id, text) => ({ type: "paragraph", id, children: [{ type: "text", text }] });
 const item = (id, text, nested) => ({ type: "list_item", id, children: [p(`${id}-p`, text), ...(nested ? [nested] : [])] });

package/dist/adapters/pdfPrint.d.ts

@@ -0,0 +1,8 @@
+import type { SmartDocument } from "smartrte-core/foundation";
+/**
+ * The only genuinely browser-specific piece of PDF export: opening a print
+ * window is a windowing operation, not format logic, so it stays here
+ * rather than in packages/core. buildPdfPrintDocument (the actual HTML
+ * content) is framework-agnostic and lives in core.
+ */
+export declare const printSmartDocumentAsPdf: (document: SmartDocument, hostWindow: Window, delayMs?: number) => boolean;

package/dist/adapters/pdfPrint.js

@@ -0,0 +1,22 @@
+import { buildPdfPrintDocument } from "smartrte-core/foundation";
+/**
+ * The only genuinely browser-specific piece of PDF export: opening a print
+ * window is a windowing operation, not format logic, so it stays here
+ * rather than in packages/core. buildPdfPrintDocument (the actual HTML
+ * content) is framework-agnostic and lives in core.
+ */
+export const printSmartDocumentAsPdf = (document, hostWindow, delayMs = 150) => {
+    const printWindow = hostWindow.open("", "_blank", "width=900,height=700");
+    if (!printWindow)
+        return false;
+    printWindow.addEventListener("load", () => {
+        printWindow.setTimeout(() => {
+            printWindow.focus();
+            printWindow.print();
+        }, delayMs);
+    }, { once: true });
+    printWindow.document.open();
+    printWindow.document.write(buildPdfPrintDocument(document));
+    printWindow.document.close();
+    return true;
+};

package/dist/adapters/shadowMode.d.ts

@@ -1,4 +1,4 @@
-import { type CommandContext, type SmartCommand, type SmartEditorState, type SmartTransaction } from "smartrte-core";
+import { type LegacyCommandContext, type SmartCommand, type SmartEditorState, type LegacySmartTransaction } from "smartrte-core/legacy";
 export interface ShadowComparison {
     commandId: string;
     matches: boolean;
@@ -15,9 +15,9 @@ export declare const reportShadowDifference: (comparison: ShadowComparison) => v
  */
 export declare const runShadowCommand: <Input>(args: {
     command: SmartCommand<Input>;
-    context: CommandContext;
+    context: LegacyCommandContext;
     input?: Input;
     state: SmartEditorState;
     legacyHtml: string;
     serialize: (state: SmartEditorState) => string;
-}) => SmartTransaction | null;
+}) => LegacySmartTransaction | null;

package/dist/adapters/shadowMode.js

@@ -1,4 +1,4 @@
-import { applyTransaction, normalizeCompatibilityHtml, } from "smartrte-core";
+import { applyTransaction, normalizeCompatibilityHtml, } from "smartrte-core/legacy";
 import { isShadowModeFlagEnabled } from "./internalFlags.js";
 const semanticHtml = (html) => normalizeCompatibilityHtml(html)
     .replace(/<(\/?)b(?=[\s>])/g, "<$1strong")