@quadrats/common 1.0.0 → 1.1.1

package/table/index.cjs.js

@@ -0,0 +1,712 @@
+'use strict';
+
+var core = require('@quadrats/core');
+var list = require('@quadrats/common/list');
+
+const TABLE_TYPE = 'table';
+const TABLE_TITLE_TYPE = 'table_title';
+const TABLE_MAIN_TYPE = 'table_main';
+const TABLE_HEADER_TYPE = 'table_header';
+const TABLE_BODY_TYPE = 'table_body';
+const TABLE_ROW_TYPE = 'table_row';
+const TABLE_CELL_TYPE = 'table_cell';
+const TABLE_TYPES = {
+    table: TABLE_TYPE,
+    table_title: TABLE_TITLE_TYPE,
+    table_main: TABLE_MAIN_TYPE,
+    table_header: TABLE_HEADER_TYPE,
+    table_body: TABLE_BODY_TYPE,
+    table_row: TABLE_ROW_TYPE,
+    table_cell: TABLE_CELL_TYPE,
+};
+// Table limits
+const TABLE_DEFAULT_MAX_COLUMNS = 6;
+const TABLE_DEFAULT_MAX_ROWS = -1;
+// 釘選欄位的最大總寬度百分比
+const MAX_PINNED_COLUMNS_WIDTH_PERCENTAGE = 40;
+const MIN_COLUMN_WIDTH_PIXEL = 60;
+const MIN_COLUMN_WIDTH_PERCENTAGE = 5;
+
+/**
+ * 將 ColumnWidth 轉換為 CSS 可用的字串
+ * @param width - 行寬定義（column width）
+ * @returns CSS 寬度字串（例如 "30%" 或 "200px"）
+ */
+function columnWidthToCSS(width) {
+    if (width.type === 'percentage') {
+        return `${width.value.toFixed(1)}%`;
+    }
+    return `${width.value}px`;
+}
+/**
+ * 計算 table 的總寬度（用於設定 min-width 以支援 overflow）
+ * 此函數會將所有 columnWidths 的百分比和 pixel 值加總：
+ * - percentage: 保留為百分比
+ * - pixel: 直接累加
+ *
+ * @param columnWidths - 行寬陣列（column widths）
+ * @returns 總寬度的 CSS 字串（例如 "calc(50% + 400px)" 或 "100%" 或 "800px"）
+ */
+function calculateTableMinWidth(columnWidths) {
+    if (columnWidths.length === 0) {
+        return '100%';
+    }
+    let totalPercentage = 0;
+    let totalPixels = 0;
+    columnWidths.forEach((width) => {
+        if (width.type === 'percentage') {
+            totalPercentage += width.value;
+        }
+        else {
+            totalPixels += width.value;
+        }
+    });
+    // 只有 percentage，沒有 pixel
+    if (totalPixels === 0) {
+        return `${totalPercentage.toFixed(1)}%`;
+    }
+    // 只有 pixel，沒有 percentage
+    if (totalPercentage === 0) {
+        return `${totalPixels}px`;
+    }
+    // 有 percentage 也有 pixel
+    // 使用 calc() 來結合兩者
+    return `calc(${totalPercentage.toFixed(1)}% + ${totalPixels}px)`;
+}
+/**
+ * 獲取 cell 的位置資訊
+ * @param editor - Slate editor
+ * @param types - Table types
+ * @param at - 可選的位置，預設使用 editor.selection
+ * @returns cell 的位置資訊，如果找不到則返回 null
+ */
+function getCellLocation(editor, types, at) {
+    const cellEntry = core.Editor.above(editor, {
+        at,
+        match: (n) => core.Element.isElement(n) && n.type === types.table_cell,
+    });
+    if (!cellEntry)
+        return null;
+    const [, cellPath] = cellEntry;
+    const columnIndex = cellPath[cellPath.length - 1];
+    const rowEntry = core.Editor.above(editor, {
+        at: cellPath,
+        match: (n) => core.Element.isElement(n) && n.type === types.table_row,
+    });
+    if (!rowEntry)
+        return null;
+    const [row, rowPath] = rowEntry;
+    const rowIndex = rowPath[rowPath.length - 1];
+    const containerEntry = core.Editor.above(editor, {
+        at: rowPath,
+        match: (n) => core.Element.isElement(n) && [types.table_header, types.table_body].includes(n.type),
+    });
+    if (!containerEntry)
+        return null;
+    const [container, containerPath] = containerEntry;
+    return {
+        cellPath,
+        columnIndex,
+        row,
+        rowPath,
+        rowIndex,
+        container,
+        containerPath,
+        isHeader: core.Element.isElement(container) && container.type === types.table_header,
+        isBody: core.Element.isElement(container) && container.type === types.table_body,
+    };
+}
+/**
+ * 獲取 table main 和相關容器資訊
+ * @param editor - Slate editor
+ * @param types - Table types
+ * @param containerPath - 當前容器的路徑
+ * @returns table 容器資訊，如果找不到則返回 null
+ */
+function getTableContainers(editor, types, containerPath) {
+    const tableMainEntry = core.Editor.above(editor, {
+        at: containerPath,
+        match: (n) => core.Element.isElement(n) && n.type === types.table_main,
+    });
+    if (!tableMainEntry)
+        return null;
+    const [tableMain, tableMainPath] = tableMainEntry;
+    const tableHeader = tableMain.children.find((child) => core.Element.isElement(child) && child.type === types.table_header);
+    const tableBody = tableMain.children.find((child) => core.Element.isElement(child) && child.type === types.table_body);
+    const tableHeaderIndex = tableHeader ? tableMain.children.findIndex((child) => child === tableHeader) : -1;
+    const tableBodyIndex = tableBody ? tableMain.children.findIndex((child) => child === tableBody) : -1;
+    return {
+        tableMain,
+        tableMainPath,
+        tableHeader,
+        tableBody,
+        tableHeaderIndex,
+        tableBodyIndex,
+    };
+}
+/**
+ * 嘗試移動到相鄰列的相同行
+ * @param location - 當前 cell 位置資訊
+ * @param direction - 移動方向（'up' 或 'down'）
+ * @param selectFn - 選擇函數（用於 move 或 extend 模式）
+ * @returns 是否成功移動
+ */
+function tryMoveToAdjacentRow(location, direction, selectFn) {
+    const { container, containerPath, rowIndex, columnIndex } = location;
+    const targetRowIndex = direction === 'up' ? rowIndex - 1 : rowIndex + 1;
+    // 嘗試在當前容器中移動
+    if (targetRowIndex >= 0 && targetRowIndex < container.children.length) {
+        const targetRow = container.children[targetRowIndex];
+        if (core.Element.isElement(targetRow)) {
+            const targetColumnIndex = Math.min(columnIndex, targetRow.children.length - 1);
+            const targetCellPath = [...containerPath, targetRowIndex, targetColumnIndex];
+            selectFn(targetCellPath, direction === 'up' ? 'start' : 'end');
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 嘗試跨容器移動（header <-> body）
+ * @param containers - Table 容器資訊
+ * @param location - 當前 cell 位置資訊
+ * @param direction - 移動方向（'up' 或 'down'）
+ * @param selectFn - 選擇函數（用於 move 或 extend 模式）
+ * @param targetColumn - 目標行索引，預設為保持當前行，設為 0 可強制移動到第一行
+ * @returns 是否成功移動
+ */
+function tryCrossBoundaryMove(containers, location, direction, selectFn, targetColumn) {
+    const { columnIndex, isHeader, isBody } = location;
+    const { tableMainPath, tableHeader, tableBody, tableHeaderIndex, tableBodyIndex } = containers;
+    // 從 body 向上移動到 header
+    if (direction === 'up' && isBody && tableHeader && core.Element.isElement(tableHeader)) {
+        const lastRowIndex = tableHeader.children.length - 1;
+        const lastRow = tableHeader.children[lastRowIndex];
+        if (core.Element.isElement(lastRow)) {
+            const targetColumnIndex = targetColumn !== undefined ? targetColumn : Math.min(columnIndex, lastRow.children.length - 1);
+            const targetCellPath = [...tableMainPath, tableHeaderIndex, lastRowIndex, targetColumnIndex];
+            selectFn(targetCellPath, 'start');
+            return true;
+        }
+    }
+    // 從 header 向下移動到 body
+    if (direction === 'down' && isHeader && tableBody && core.Element.isElement(tableBody)) {
+        const firstRow = tableBody.children[0];
+        if (core.Element.isElement(firstRow)) {
+            const targetColumnIndex = targetColumn !== undefined ? targetColumn : Math.min(columnIndex, firstRow.children.length - 1);
+            const targetCellPath = [...tableMainPath, tableBodyIndex, 0, targetColumnIndex];
+            // Tab 導航時使用 'start'，上下鍵導航時使用 'end'
+            const position = targetColumn === 0 ? 'start' : 'end';
+            selectFn(targetCellPath, position);
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 嘗試移動到下一個 cell
+ * @param location - 當前 cell 位置資訊
+ * @param selectFn - 選擇函數
+ * @returns 是否成功移動
+ */
+function tryMoveToNextCell(location, selectFn) {
+    const { cellPath, row, rowPath, container, containerPath, rowIndex } = location;
+    const currentColumnIndex = cellPath[cellPath.length - 1];
+    const nextColumnIndex = currentColumnIndex + 1;
+    if (nextColumnIndex < row.children.length) {
+        const targetCellPath = [...rowPath, nextColumnIndex];
+        selectFn(targetCellPath, 'start');
+        return true;
+    }
+    const nextRowIndex = rowIndex + 1;
+    if (nextRowIndex < container.children.length) {
+        const nextRow = container.children[nextRowIndex];
+        if (core.Element.isElement(nextRow) && nextRow.children.length > 0) {
+            const targetCellPath = [...containerPath, nextRowIndex, 0];
+            selectFn(targetCellPath, 'start');
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 嘗試在水平方向擴展選擇（左右移動）
+ * @param editor - Slate editor
+ * @param location - 當前 cell 位置資訊
+ * @param direction - 移動方向（'left' 或 'right'）
+ * @param anchor - 選擇的起點
+ * @returns 是否成功擴展
+ */
+function tryExtendSelectionHorizontal(editor, location, direction, anchor) {
+    var _a;
+    const { cellPath, columnIndex, row, rowPath } = location;
+    const focus = (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus;
+    if (!focus)
+        return false;
+    const isLeftDirection = direction === 'left';
+    const isAtBoundary = isLeftDirection ? columnIndex === 0 : columnIndex >= row.children.length - 1;
+    // 如果已經在邊界，嘗試擴展到該 cell 的開頭或結尾
+    if (isAtBoundary) {
+        const boundaryPoint = isLeftDirection ? core.Editor.start(editor, cellPath) : core.Editor.end(editor, cellPath);
+        // 只有當 focus 還沒到邊界時才移動
+        const shouldMove = isLeftDirection
+            ? focus.offset > boundaryPoint.offset || focus.path.length !== boundaryPoint.path.length
+            : focus.offset < boundaryPoint.offset || focus.path.length !== boundaryPoint.path.length;
+        if (shouldMove) {
+            core.Transforms.select(editor, { anchor, focus: boundaryPoint });
+        }
+        return true;
+    }
+    // 找到目標 cell
+    const targetColumnIndex = isLeftDirection ? columnIndex - 1 : columnIndex + 1;
+    const targetCellPath = [...rowPath, targetColumnIndex];
+    // 根據方向選擇目標點（左邊用 end，右邊用 start）
+    const targetPoint = isLeftDirection ? core.Editor.end(editor, targetCellPath) : core.Editor.start(editor, targetCellPath);
+    // 保持 anchor 不變，移動 focus
+    core.Transforms.select(editor, { anchor, focus: targetPoint });
+    return true;
+}
+
+function createTable(options = {}) {
+    const { types: typesOptions } = options;
+    const types = Object.assign(Object.assign({}, TABLE_TYPES), typesOptions);
+    const createTableElement = (rows, cols) => {
+        return [
+            {
+                type: types.table,
+                children: [
+                    { type: types.table_title, children: [{ text: '' }] },
+                    {
+                        type: types.table_main,
+                        children: [
+                            {
+                                type: types.table_body,
+                                children: Array.from({ length: rows }, () => ({
+                                    type: types.table_row,
+                                    children: Array.from({ length: cols }, () => ({
+                                        type: types.table_cell,
+                                        children: [
+                                            {
+                                                type: core.PARAGRAPH_TYPE,
+                                                children: [{ text: '' }],
+                                            },
+                                        ],
+                                    })),
+                                })),
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                type: core.PARAGRAPH_TYPE,
+                children: [{ text: '' }],
+            },
+        ];
+    };
+    const isSelectionInTableMain = (editor) => core.isNodesTypeIn(editor, [types.table_main]);
+    const isSelectionInTableCell = (editor) => core.isNodesTypeIn(editor, [types.table_cell]);
+    const isSelectionInTableRow = (editor) => core.isNodesTypeIn(editor, [types.table_row]);
+    const isSelectionInTableHeader = (editor) => core.isNodesTypeIn(editor, [types.table_header]);
+    const isSelectionInTableBody = (editor) => core.isNodesTypeIn(editor, [types.table_body]);
+    const isSelectionInTableList = (editor) => core.isNodesTypeIn(editor, [list.LIST_TYPES.ol, list.LIST_TYPES.ul]);
+    const insertTable = (editor, rows, cols) => {
+        core.Transforms.insertNodes(editor, createTableElement(rows, cols));
+    };
+    const moveToNextCell = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const location = getCellLocation(editor, types);
+            if (!location)
+                return;
+            const selectFn = (cellPath, position) => {
+                const point = core.Editor[position](editor, cellPath);
+                core.Transforms.select(editor, point);
+            };
+            // 嘗試移動到下一個 cell（同一列或下一列）
+            if (tryMoveToNextCell(location, selectFn))
+                return;
+            // 如果在 header，嘗試移動到 body 的第一個 cell（第一行）
+            const containers = getTableContainers(editor, types, location.containerPath);
+            if (!containers)
+                return;
+            // 使用 tryCrossBoundaryMove，指定 targetColumn 為 0（Tab 導航總是移動到第一行）
+            if (tryCrossBoundaryMove(containers, location, 'down', selectFn, 0))
+                return;
+        }
+        catch (error) {
+            console.warn('Failed to move to next cell:', error);
+        }
+    };
+    const moveToRowAbove = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const location = getCellLocation(editor, types);
+            if (!location)
+                return;
+            const selectFn = (cellPath, position) => {
+                const point = core.Editor[position](editor, cellPath);
+                core.Transforms.select(editor, point);
+            };
+            // 嘗試移動到相鄰列（同一行）
+            if (tryMoveToAdjacentRow(location, 'up', selectFn))
+                return;
+            // 嘗試跨容器移動
+            const containers = getTableContainers(editor, types, location.containerPath);
+            if (!containers)
+                return;
+            if (tryCrossBoundaryMove(containers, location, 'up', selectFn))
+                return;
+        }
+        catch (error) {
+            console.warn('Failed to move to row above:', error);
+        }
+    };
+    const moveToRowBelow = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const location = getCellLocation(editor, types);
+            if (!location)
+                return;
+            const selectFn = (cellPath, position) => {
+                const point = core.Editor[position](editor, cellPath);
+                core.Transforms.select(editor, point);
+            };
+            // 嘗試移動到相鄰列（同一行）
+            if (tryMoveToAdjacentRow(location, 'down', selectFn))
+                return;
+            // 嘗試跨容器移動
+            const containers = getTableContainers(editor, types, location.containerPath);
+            if (!containers)
+                return;
+            if (tryCrossBoundaryMove(containers, location, 'down', selectFn))
+                return;
+        }
+        catch (error) {
+            console.warn('Failed to move to row below:', error);
+        }
+    };
+    const extendSelectionLeft = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const { anchor, focus } = editor.selection;
+            const location = getCellLocation(editor, types, focus);
+            if (!location)
+                return;
+            tryExtendSelectionHorizontal(editor, location, 'left', anchor);
+        }
+        catch (error) {
+            console.warn('Failed to extend selection left:', error);
+        }
+    };
+    const extendSelectionRight = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const { anchor, focus } = editor.selection;
+            const location = getCellLocation(editor, types, focus);
+            if (!location)
+                return;
+            tryExtendSelectionHorizontal(editor, location, 'right', anchor);
+        }
+        catch (error) {
+            console.warn('Failed to extend selection right:', error);
+        }
+    };
+    const extendSelectionUp = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const { anchor } = editor.selection;
+            const location = getCellLocation(editor, types, editor.selection.focus);
+            if (!location)
+                return;
+            const selectFn = (cellPath, position) => {
+                const point = core.Editor[position](editor, cellPath);
+                core.Transforms.select(editor, { anchor, focus: point });
+            };
+            // 嘗試移動到相鄰列（同一行）
+            if (tryMoveToAdjacentRow(location, 'up', selectFn))
+                return;
+            // 嘗試跨容器移動
+            const containers = getTableContainers(editor, types, location.containerPath);
+            if (!containers)
+                return;
+            if (tryCrossBoundaryMove(containers, location, 'up', selectFn))
+                return;
+        }
+        catch (error) {
+            console.warn('Failed to extend selection up:', error);
+        }
+    };
+    const extendSelectionDown = (editor, types) => {
+        if (!editor.selection)
+            return;
+        try {
+            const { anchor } = editor.selection;
+            const location = getCellLocation(editor, types, editor.selection.focus);
+            if (!location)
+                return;
+            const selectFn = (cellPath, position) => {
+                const point = core.Editor[position](editor, cellPath);
+                core.Transforms.select(editor, { anchor, focus: point });
+            };
+            // 嘗試移動到相鄰列（同一行）
+            if (tryMoveToAdjacentRow(location, 'down', selectFn))
+                return;
+            // 嘗試跨容器移動
+            const containers = getTableContainers(editor, types, location.containerPath);
+            if (!containers)
+                return;
+            if (tryCrossBoundaryMove(containers, location, 'down', selectFn))
+                return;
+        }
+        catch (error) {
+            console.warn('Failed to extend selection down:', error);
+        }
+    };
+    return {
+        types,
+        createTableElement,
+        insertTable,
+        isSelectionInTableMain,
+        isSelectionInTableCell,
+        isSelectionInTableRow,
+        isSelectionInTableHeader,
+        isSelectionInTableBody,
+        isSelectionInTableList,
+        moveToNextCell,
+        moveToRowAbove,
+        moveToRowBelow,
+        extendSelectionLeft,
+        extendSelectionRight,
+        extendSelectionUp,
+        extendSelectionDown,
+        with(editor) {
+            const { insertFragment, deleteBackward } = editor;
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node)) {
+                    const type = node.type;
+                    // 1. 防止巢狀 table
+                    if (type === types.table) {
+                        for (const [, childPath] of core.Editor.nodes(editor, {
+                            at: path,
+                            match: (n) => core.Element.isElement(n) && n.type === types.table,
+                        })) {
+                            if (childPath.length > path.length) {
+                                core.Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                        // 確保 table 有必要的結構：title + main
+                        const children = node.children.filter((child) => core.Element.isElement(child));
+                        const titleChild = children.find((child) => child.type === types.table_title);
+                        const mainChild = children.find((child) => child.type === types.table_main);
+                        if (!titleChild) {
+                            core.Transforms.insertNodes(editor, { type: types.table_title, children: [{ text: '' }] }, {
+                                at: [...path, 0],
+                            });
+                            return;
+                        }
+                        if (!mainChild) {
+                            const mainIndex = titleChild ? 1 : 0;
+                            const tableMain = {
+                                type: types.table_main,
+                                children: [
+                                    {
+                                        type: types.table_body,
+                                        children: [
+                                            {
+                                                type: types.table_row,
+                                                children: [
+                                                    {
+                                                        type: types.table_cell,
+                                                        children: [
+                                                            {
+                                                                type: core.PARAGRAPH_TYPE,
+                                                                children: [{ text: '' }],
+                                                            },
+                                                        ],
+                                                    },
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                            core.Transforms.insertNodes(editor, tableMain, { at: [...path, mainIndex] });
+                            return;
+                        }
+                    }
+                    // 2. table_main 必須至少有一個 table_body
+                    if (type === types.table_main) {
+                        const children = node.children.filter((child) => core.Element.isElement(child));
+                        const bodyChild = children.find((child) => child.type === types.table_body);
+                        if (!bodyChild) {
+                            const tableBody = {
+                                type: types.table_body,
+                                children: [
+                                    {
+                                        type: types.table_row,
+                                        children: [
+                                            {
+                                                type: types.table_cell,
+                                                children: [
+                                                    {
+                                                        type: core.PARAGRAPH_TYPE,
+                                                        children: [{ text: '' }],
+                                                    },
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                            core.Transforms.insertNodes(editor, tableBody, { at: [...path, children.length] });
+                            return;
+                        }
+                    }
+                    // 3. table_header 和 table_body 必須有合理的 row 結構
+                    if (type === types.table_header) {
+                        const children = node.children.filter((child) => core.Element.isElement(child));
+                        const rowChildren = children.filter((child) => child.type === types.table_row);
+                        // 如果 header 沒有任何 row，移除整個 header
+                        if (rowChildren.length === 0) {
+                            core.Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                    if (type === types.table_body) {
+                        const children = node.children.filter((child) => core.Element.isElement(child));
+                        const rowChildren = children.filter((child) => child.type === types.table_row);
+                        // body 必須至少有一個 row
+                        if (rowChildren.length === 0) {
+                            const tableRow = {
+                                type: types.table_row,
+                                children: [
+                                    {
+                                        type: types.table_cell,
+                                        children: [
+                                            {
+                                                type: core.PARAGRAPH_TYPE,
+                                                children: [{ text: '' }],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                            core.Transforms.insertNodes(editor, tableRow, { at: [...path, 0] });
+                            return;
+                        }
+                    }
+                    // 4. table_cell 只允許 paragraph、list
+                    if (type === types.table_cell) {
+                        const allowedTypes = [core.PARAGRAPH_TYPE, list.LIST_TYPES.ul, list.LIST_TYPES.ol];
+                        for (const [child, childPath] of core.Node.children(editor, path)) {
+                            if (core.Element.isElement(child)) {
+                                const childType = child.type;
+                                // 如果不在白名單中，直接移除
+                                if (!allowedTypes.includes(childType)) {
+                                    core.Transforms.removeNodes(editor, { at: childPath });
+                                    return;
+                                }
+                            }
+                            else if (!core.Text.isText(child)) {
+                                // 如果不是 Element 也不是 Text，移除
+                                core.Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                    }
+                }
+            };
+            editor.deleteBackward = (unit) => {
+                const { selection } = editor;
+                if (selection) {
+                    // 檢查是否在 table_title 中
+                    const titleEntry = core.Editor.above(editor, {
+                        match: (n) => core.Element.isElement(n) && n.type === types.table_title,
+                    });
+                    if (titleEntry) {
+                        const [, titlePath] = titleEntry;
+                        if (core.Editor.isStart(editor, selection.anchor, titlePath)) {
+                            // 在 table_title 開頭按 backspace，不執行任何操作
+                            return;
+                        }
+                    }
+                    // 檢查是否在 table_cell 中
+                    const cellEntry = core.Editor.above(editor, {
+                        match: (n) => core.Element.isElement(n) && n.type === types.table_cell,
+                    });
+                    if (cellEntry) {
+                        const [, cellPath] = cellEntry;
+                        if (core.Editor.isStart(editor, selection.anchor, cellPath)) {
+                            // 在 table_cell 開頭按 backspace，不執行任何操作
+                            return;
+                        }
+                    }
+                }
+                // 執行預設的 deleteBackward 行為
+                deleteBackward(unit);
+            };
+            /** 複製 Table Cell 內文字時觸發 */
+            editor.insertFragment = (fragment) => {
+                const cellEntry = core.Editor.above(editor, {
+                    match: (n) => core.Element.isElement(n) && n.type === types.table_cell,
+                });
+                if (cellEntry) {
+                    // 在 table cell 中貼上時，只保留文字內容，不保留結構
+                    const textNodes = [];
+                    const extractText = (nodes) => {
+                        for (const node of nodes) {
+                            if (core.Element.isElement(node)) {
+                                extractText(node.children);
+                            }
+                            else if (node.text !== undefined) {
+                                textNodes.push(node);
+                            }
+                        }
+                    };
+                    extractText(fragment);
+                    // 如果有文字節點，將它們包裝成一個 paragraph 插入
+                    if (textNodes.length) {
+                        const textContent = textNodes.map((node) => node.text).join('');
+                        core.Transforms.insertText(editor, textContent);
+                        return;
+                    }
+                }
+                // 預設行為
+                insertFragment(fragment);
+            };
+            return editor;
+        },
+    };
+}
+
+exports.MAX_PINNED_COLUMNS_WIDTH_PERCENTAGE = MAX_PINNED_COLUMNS_WIDTH_PERCENTAGE;
+exports.MIN_COLUMN_WIDTH_PERCENTAGE = MIN_COLUMN_WIDTH_PERCENTAGE;
+exports.MIN_COLUMN_WIDTH_PIXEL = MIN_COLUMN_WIDTH_PIXEL;
+exports.TABLE_BODY_TYPE = TABLE_BODY_TYPE;
+exports.TABLE_CELL_TYPE = TABLE_CELL_TYPE;
+exports.TABLE_DEFAULT_MAX_COLUMNS = TABLE_DEFAULT_MAX_COLUMNS;
+exports.TABLE_DEFAULT_MAX_ROWS = TABLE_DEFAULT_MAX_ROWS;
+exports.TABLE_HEADER_TYPE = TABLE_HEADER_TYPE;
+exports.TABLE_MAIN_TYPE = TABLE_MAIN_TYPE;
+exports.TABLE_ROW_TYPE = TABLE_ROW_TYPE;
+exports.TABLE_TITLE_TYPE = TABLE_TITLE_TYPE;
+exports.TABLE_TYPE = TABLE_TYPE;
+exports.TABLE_TYPES = TABLE_TYPES;
+exports.calculateTableMinWidth = calculateTableMinWidth;
+exports.columnWidthToCSS = columnWidthToCSS;
+exports.createTable = createTable;
+exports.getCellLocation = getCellLocation;
+exports.getTableContainers = getTableContainers;
+exports.tryCrossBoundaryMove = tryCrossBoundaryMove;
+exports.tryExtendSelectionHorizontal = tryExtendSelectionHorizontal;
+exports.tryMoveToAdjacentRow = tryMoveToAdjacentRow;
+exports.tryMoveToNextCell = tryMoveToNextCell;