smartrte-react 0.3.5 → 1.0.0-beta.10

package/dist/adapters/domInlineImageCommandBridge.js

@@ -1,72 +1,6 @@
-import { createSmartEditor, getNodeAtPath, mediaPlugin, } from "smartrte-core";
-import { selectionFromDom } from "./domSelectionBridge.js";
-import { smartDocumentFromEditorRoot } from "./domSmartDocument.js";
-import { inlineAtomPathFromDom } from "./domInlineAtomCommandBridge.js";
-/**
- * Executes inline image insertion through core and projects only the resulting
- * atom into the existing DOM range. Unrelated DOM and metadata stay untouched.
- */
-export const executeDomInlineImageCommand = (root, input, domSelection = root.ownerDocument.defaultView?.getSelection() || null) => {
-    if (!domSelection?.rangeCount || !domSelection.isCollapsed)
-        return null;
-    const modelSelection = selectionFromDom(root, domSelection);
-    if (!modelSelection)
-        return null;
-    const { document } = smartDocumentFromEditorRoot(root);
-    const editor = createSmartEditor({
-        state: { document, selection: modelSelection },
-        plugins: [mediaPlugin],
-    });
-    if (!editor.execute("image.insert-inline", input))
-        return null;
-    const selectionAfter = editor.state.selection;
-    if (selectionAfter.type !== "text")
-        return null;
-    const imagePath = [
-        ...selectionAfter.anchor.path.slice(0, -1),
-        selectionAfter.anchor.path[selectionAfter.anchor.path.length - 1] - 1,
-    ];
-    const atom = getNodeAtPath(editor.state.document, imagePath);
-    if (atom?.type !== "inlineImage")
-        return null;
-    const range = domSelection.getRangeAt(0);
-    const image = root.ownerDocument.createElement("img");
-    image.src = atom.src;
-    image.alt = atom.alt || "";
-    if (atom.title)
-        image.title = atom.title;
-    if (atom.width)
-        image.width = atom.width;
-    if (atom.height)
-        image.height = atom.height;
-    image.dataset.srteInline = "true";
-    range.insertNode(image);
-    range.setStartAfter(image);
-    range.collapse(true);
-    domSelection.removeAllRanges();
-    domSelection.addRange(range);
-    return image;
-};
-/** Validates an inline image attribute update through core, then mutates it in place. */
-export const executeDomInlineImageUpdate = (root, image, input) => {
-    const path = inlineAtomPathFromDom(root, image);
-    if (!path)
-        return false;
-    const selection = selectionFromDom(root, root.ownerDocument.defaultView?.getSelection() || null) || { type: "node", path };
-    const { document } = smartDocumentFromEditorRoot(root);
-    const editor = createSmartEditor({
-        state: { document, selection },
-        plugins: [mediaPlugin],
-    });
-    if (!editor.execute("image.update-inline", { path, ...input }))
-        return false;
-    if (input.alt !== undefined)
-        image.alt = input.alt;
-    if (input.title !== undefined)
-        image.title = input.title;
-    if (input.width !== undefined)
-        image.width = input.width;
-    if (input.height !== undefined)
-        image.height = input.height;
-    return true;
-};
+import { executeDomCanonicalAtomInsert, executeDomCanonicalAtomUpdate } from "./domInlineAtomCommandBridge.js";
+export const executeDomInlineImageCommand = (root, input, selection = root.ownerDocument.defaultView?.getSelection() || null) => executeDomCanonicalAtomInsert(root, {
+    type: "image",
+    attrs: { src: input.src, alt: input.alt ?? "", decorative: input.decorative === true, status: input.status || "ready", ...(input.uploadId ? { uploadId: input.uploadId } : {}), ...(input.error ? { error: input.error } : {}), ...(input.title ? { title: input.title } : {}), ...(input.width ? { width: input.width } : {}), ...(input.height ? { height: input.height } : {}) },
+}, selection);
+export const executeDomInlineImageUpdate = (root, image, input) => executeDomCanonicalAtomUpdate(root, image, input);

package/dist/adapters/domMoveCommandBridge.js

@@ -1,4 +1,4 @@
-import { createSmartEditor, movePlugin } from "smartrte-core";
+import { createSmartEditor, movePlugin } from "smartrte-core/legacy";
 import { smartDocumentFromHtml } from "./domSmartDocument.js";
 /**
  * Executes model move/indent commands while preserving the existing DOM nodes.

package/dist/adapters/domSelectionBridge.d.ts

@@ -1,8 +1,8 @@
-import type { Path, SmartSelection } from "smartrte-core";
+import type { Path, LegacySmartSelection } from "smartrte-core/legacy";
 export declare const isEditorOnlyElement: (node: Element) => boolean;
 /** Returns the semantic model path for a DOM element at the adapter boundary. */
 export declare const pathForDomElement: (element: Element, editor: HTMLElement) => Path | null;
 /** Converts browser selection into a core selection without exposing editor UI nodes. */
-export declare const selectionFromDom: (editor: HTMLElement, selection: Selection | null) => SmartSelection | null;
+export declare const selectionFromDom: (editor: HTMLElement, selection: Selection | null) => LegacySmartSelection | null;
 /** Restores a text selection from core paths after the editor DOM is rebuilt. */
-export declare const restoreSelectionToDom: (editor: HTMLElement, smartSelection: SmartSelection) => boolean;
+export declare const restoreSelectionToDom: (editor: HTMLElement, smartSelection: LegacySmartSelection) => boolean;

package/dist/adapters/domSmartDocument.d.ts

@@ -1,10 +1,10 @@
-import { type SmartDocument } from "smartrte-core";
+import { type LegacySmartDocument } from "smartrte-core/legacy";
 /** Removes editor UI before handing the document to the core parser boundary. */
 export declare const cleanEditorHtml: (root: HTMLElement) => string;
-export declare const smartDocumentFromHtml: (html: string, ownerDocument: Document) => SmartDocument;
+export declare const smartDocumentFromHtml: (html: string, ownerDocument: Document) => LegacySmartDocument;
 export declare const smartDocumentFromEditorRoot: (root: HTMLElement) => {
-    document: SmartDocument;
+    document: LegacySmartDocument;
     html: string;
 };
 /** Serializes the shadow-only model. It is not used for persisted editor HTML. */
-export declare const serializeSmartDocument: (document: SmartDocument) => string;
+export declare const serializeSmartDocument: (document: LegacySmartDocument) => string;

package/dist/adapters/domSmartDocument.js

@@ -1,5 +1,5 @@
-import { normalizeCompatibilityHtml, sanitizeLinkAttrs, } from "smartrte-core";
-import { isSmartListPreset } from "smartrte-core";
+import { normalizeCompatibilityHtml, sanitizeLinkAttrs, } from "smartrte-core/legacy";
+import { isSmartListPreset } from "smartrte-core/legacy";
 import { isEditorOnlyElement } from "./domSelectionBridge.js";
 const blockTags = new Set(["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "table", "img", "video", "audio"]);
 const unwrap = (element) => {

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;