@phuong-tran-redoc/document-engine-core 0.1.0 → 0.1.2

package/src/extensions/table-resizing.extension.js

@@ -1,164 +0,0 @@
-import { Extension } from '@tiptap/core';
-import { Plugin, PluginKey } from '@tiptap/pm/state';
-import { tableNodeTypes } from '@tiptap/pm/tables';
-import { Decoration, DecorationSet } from '@tiptap/pm/view';
-import { getTableDOMFromView } from '../utils';
-/**
- * Handler for mouse move (dragging)
- */ function handleMouseMoveEvent(event, dragInfo) {
-    if (!dragInfo.isDragging) return;
-    event.preventDefault();
-    const { startX, tableWidthPx, initialLeftWidth, initialRightWidth, leftColIndex, tablePos, tableNode, view } = dragInfo;
-    // 1. Compute the delta (pixels)
-    const deltaX = event.clientX - startX;
-    // 2. Convert the pixel delta into a percentage delta
-    // This is the most important piece of logic
-    const deltaPercent = deltaX / tableWidthPx * 100;
-    // 3. Compute the new widths
-    let newLeftWidth = initialLeftWidth + deltaPercent;
-    let newRightWidth = initialRightWidth - deltaPercent;
-    // 4. Apply constraints (e.g. min-width 5%)
-    const minWidth = 5; // min-width configuration
-    if (newLeftWidth < minWidth) {
-        const diff = minWidth - newLeftWidth;
-        newLeftWidth = minWidth;
-        newRightWidth = newRightWidth - diff; // Right column absorbs the shortfall
-    } else if (newRightWidth < minWidth) {
-        const diff = minWidth - newRightWidth;
-        newRightWidth = minWidth;
-        newLeftWidth = newLeftWidth - diff; // Left column absorbs the shortfall
-    }
-    // Make sure no column goes negative (in case of a very fast drag)
-    if (newLeftWidth < 0) newLeftWidth = 0;
-    if (newRightWidth < 0) newRightWidth = 0;
-    // 5. Build the new colwidths array
-    const newColWidths = [
-        ...tableNode?.attrs?.['colwidths']
-    ];
-    newColWidths[leftColIndex] = newLeftWidth;
-    newColWidths[leftColIndex + 1] = newRightWidth;
-    // 6. Dispatch a transaction to update the state
-    if (tableNode && view) {
-        const tr = view.state.tr.setNodeMarkup(tablePos, null, {
-            ...tableNode.attrs,
-            colwidths: newColWidths
-        });
-        // Use dispatchTransaction so Tiptap/ProseMirror updates the UI itself
-        view.dispatch(tr);
-    }
-}
-/**
- * Handler for mouse up (end of drag)
- */ function handleMouseUpEvent(event, dragInfo) {
-    if (!dragInfo.isDragging) return;
-    event.preventDefault();
-    // Reset the state
-    dragInfo = {
-        isDragging: false,
-        startX: 0,
-        tablePos: -1,
-        tableNode: null,
-        tableWidthPx: 0,
-        leftColIndex: -1,
-        initialLeftWidth: 0,
-        initialRightWidth: 0,
-        view: null
-    };
-}
-/**
- * Extension PercentageColumnResizing
- * * Replaces the default column-resize logic with percentage-based logic.
- */ export const PercentageColumnResizing = Extension.create({
-    name: 'percentageColumnResizing',
-    addProseMirrorPlugins () {
-        // A temporary object to hold the drag-and-drop state
-        // We don't use Plugin State because this state never needs to be "undone"
-        let dragInfo = {
-            isDragging: false,
-            startX: 0,
-            tablePos: -1,
-            tableNode: null,
-            tableWidthPx: 0,
-            leftColIndex: -1,
-            initialLeftWidth: 0,
-            initialRightWidth: 0,
-            view: null
-        };
-        const editorInstance = this.editor;
-        return [
-            new Plugin({
-                key: new PluginKey('percentageColumnResizing'),
-                props: {
-                    /**
-           * Draw the resize handles into the DOM
-           */ decorations (state) {
-                        if (!editorInstance?.isEditable) return;
-                        const decorations = [];
-                        const { doc } = state;
-                        const tableTypes = tableNodeTypes(state.schema);
-                        // Walk every node in the document
-                        doc.descendants((node, pos)=>{
-                            if (node.type.name !== tableTypes.table.name) return;
-                            const colwidths = node.attrs['colwidths'];
-                            if (!colwidths || colwidths.length === 0) return;
-                            let accumulatedWidth = 0;
-                            // Create a handle for N-1 columns (the last column doesn't need one)
-                            for(let i = 0; i < colwidths.length - 1; i++){
-                                accumulatedWidth += colwidths[i] ?? 0;
-                                // Create a 'div' widget to act as the handle
-                                const handle = document.createElement('div');
-                                handle.className = 'pm-col-resizer';
-                                handle.style.left = `calc(${accumulatedWidth}% - 2px)`;
-                                // Store the column position so we know which column is being resized
-                                handle.setAttribute('data-col-index', i.toString());
-                                handle.setAttribute('data-table-pos', pos.toString());
-                                // Place the widget right after the <table> tag (pos + 1)
-                                decorations.push(Decoration.widget(pos + 1, handle));
-                            }
-                        });
-                        return DecorationSet.create(doc, decorations);
-                    },
-                    /**
-           * Handle the mousedown event on a handle
-           */ handleDOMEvents: {
-                        mousedown (view, event) {
-                            const target = event.target;
-                            // Only trigger when clicking on a handle
-                            if (!target.classList.contains('pm-col-resizer')) return false;
-                            event.preventDefault();
-                            const colIndex = parseInt(target.getAttribute('data-col-index') ?? '0', 10);
-                            const tablePos = parseInt(target.getAttribute('data-table-pos') ?? '0', 10);
-                            const tableNode = view.state.doc.nodeAt(tablePos);
-                            const colwidths = tableNode?.attrs['colwidths'];
-                            if (!tableNode || !colwidths) return false;
-                            // Get table DOM element (handles NodeView wrappers and nested tables)
-                            const tableDOM = getTableDOMFromView(view, tablePos);
-                            if (!tableDOM) return false;
-                            // Store the info needed for dragging
-                            dragInfo = {
-                                isDragging: true,
-                                startX: event.clientX,
-                                tablePos: tablePos,
-                                tableNode: tableNode,
-                                tableWidthPx: tableDOM.offsetWidth,
-                                leftColIndex: colIndex,
-                                initialLeftWidth: colwidths[colIndex],
-                                initialRightWidth: colwidths[colIndex + 1],
-                                view: view
-                            };
-                            const handleMouseMove = (event)=>handleMouseMoveEvent(event, dragInfo);
-                            const handleMouseUp = (event)=>{
-                                handleMouseUpEvent(event, dragInfo);
-                                window.removeEventListener('mousemove', handleMouseMove, true);
-                                window.removeEventListener('mouseup', handleMouseUp, true);
-                            };
-                            window.addEventListener('mousemove', handleMouseMove, true);
-                            window.addEventListener('mouseup', handleMouseUp, true);
-                            return true; // Event handled
-                        }
-                    }
-                }
-            })
-        ];
-    }
-});

package/src/extensions/table-style.extension.js

@@ -1,481 +0,0 @@
-import { Extension } from '@tiptap/core';
-import { Table, TableCell, TableHeader, TableRow } from '@tiptap/extension-table';
-import { TextSelection } from '@tiptap/pm/state';
-import { addColumnAfter, addColumnBefore, deleteColumn, selectionCell, TableMap } from '@tiptap/pm/tables';
-import { MIN_NEW_COL_WIDTH } from '../constants/table.constant';
-import { getCursorCellInfo } from '../utils';
-import { createTableNodeView } from '../views';
-import { PercentageColumnResizing } from './table-resizing.extension';
-/**
- * Calculate new column widths when adding a column, ensuring no column goes below MIN_NEW_COL_WIDTH
- * @param oldColWidths - Array of current column widths
- * @returns Array of adjusted column widths (without the new column inserted yet)
- */ function calculateColumnWidthsForNewColumn(oldColWidths) {
-    // Find columns that can contribute (above minimum)
-    const columnsAboveMin = oldColWidths.filter((w)=>w > MIN_NEW_COL_WIDTH);
-    // If not enough space, proportionally reduce all columns
-    if (columnsAboveMin.length === 0) {
-        const reduction = MIN_NEW_COL_WIDTH / oldColWidths.length;
-        return oldColWidths.map((w)=>w - reduction);
-    }
-    // Calculate available space from columns above minimum
-    const availableSpace = columnsAboveMin.reduce((sum, w)=>sum + (w - MIN_NEW_COL_WIDTH), 0);
-    // If we have enough space, only tax columns above minimum
-    if (availableSpace >= MIN_NEW_COL_WIDTH) {
-        return oldColWidths.map((w)=>{
-            if (w > MIN_NEW_COL_WIDTH) {
-                const contribution = (w - MIN_NEW_COL_WIDTH) / availableSpace * MIN_NEW_COL_WIDTH;
-                return Math.max(MIN_NEW_COL_WIDTH, w - contribution);
-            }
-            return w;
-        });
-    }
-    // Not enough space even from columns above min, reduce proportionally
-    const reduction = MIN_NEW_COL_WIDTH / oldColWidths.length;
-    return oldColWidths.map((w)=>w - reduction);
-}
-export const TableDefaultAttributes = {
-    border: {
-        style: 'double',
-        color: '#e5e7eb',
-        width: '1px'
-    },
-    backgroundColor: null,
-    colwidths: null,
-    cellBorder: {
-        style: 'solid',
-        color: '#e5e7eb',
-        width: '1px'
-    },
-    cellBackgroundColor: null,
-    cellVerticalAlign: 'middle',
-    cellTextAlign: null
-};
-// Extend TableCell and TableHeader to support styling attributes
-const commonCellAttributes = {
-    backgroundColor: {
-        default: null,
-        renderHTML: (attrs)=>attrs.backgroundColor ? {
-                style: `background-color: ${attrs.backgroundColor};`
-            } : {},
-        parseHTML: (element)=>element.style.getPropertyValue('background-color') || null
-    },
-    border: {
-        default: TableDefaultAttributes.cellBorder,
-        renderHTML: (attrs)=>{
-            const border = attrs['border'];
-            if (!border) return {};
-            const styles = [];
-            if (border.style) styles.push(`border-style: ${border.style}`);
-            if (border.color) styles.push(`border-color: ${border.color}`);
-            if (border.width) styles.push(`border-width: ${border.width}`);
-            return styles.length ? {
-                style: styles.join('; ') + ';'
-            } : {};
-        },
-        parseHTML: (element)=>{
-            const style = element.style.getPropertyValue('border-style');
-            const color = element.style.getPropertyValue('border-color');
-            const width = element.style.getPropertyValue('border-width');
-            if (!style && !color && !width) return null;
-            return {
-                style: style || null,
-                color: color || null,
-                width: width || null
-            };
-        }
-    },
-    verticalAlign: {
-        default: TableDefaultAttributes.cellVerticalAlign,
-        renderHTML: (attrs)=>attrs.verticalAlign ? {
-                style: `vertical-align: ${attrs.verticalAlign};`
-            } : {},
-        parseHTML: (element)=>element.style.getPropertyValue('vertical-align') || null
-    },
-    textAlign: {
-        default: TableDefaultAttributes.cellTextAlign,
-        renderHTML: (attrs)=>attrs.textAlign ? {
-                style: `text-align: ${attrs.textAlign};`
-            } : {},
-        parseHTML: (element)=>element.style.getPropertyValue('text-align') || null
-    }
-};
-export const StyledTableCell = TableCell.extend({
-    addAttributes () {
-        const parent = this.parent?.() ?? {};
-        return {
-            ...parent,
-            ...commonCellAttributes
-        };
-    }
-});
-export const StyledTableHeader = TableHeader.extend({
-    addAttributes () {
-        const parent = this.parent?.() ?? {};
-        return {
-            ...parent,
-            ...commonCellAttributes
-        };
-    }
-});
-// Extend Table node to support width (%) and alignment (left|center|right)
-export const StyledTable = Table.extend({
-    // name: 'styledTable',
-    // draggable: true,
-    addOptions () {
-        return {
-            ...this.parent?.(),
-            enableNodeView: true
-        };
-    },
-    addAttributes () {
-        const parent = this.parent?.() ?? {};
-        return {
-            ...parent,
-            border: {
-                default: null,
-                renderHTML: (attrs)=>{
-                    const border = attrs.border;
-                    if (!border) return {};
-                    const styles = [];
-                    if (border.style) styles.push(`border-style: ${border.style}`);
-                    if (border.color) styles.push(`border-color: ${border.color}`);
-                    if (border.width) styles.push(`border-width: ${border.width}`);
-                    return styles.length ? {
-                        style: styles.join('; ') + ';'
-                    } : {};
-                },
-                parseHTML: (element)=>{
-                    const style = element.style.getPropertyValue('border-style');
-                    const color = element.style.getPropertyValue('border-color');
-                    const width = element.style.getPropertyValue('border-width');
-                    if (!style && !color && !width) return null;
-                    return {
-                        style: style || null,
-                        color: color || null,
-                        width: width || null
-                    };
-                }
-            },
-            backgroundColor: {
-                default: null,
-                renderHTML: (attrs)=>attrs.backgroundColor ? {
-                        style: `background-color: ${attrs.backgroundColor};`
-                    } : {},
-                parseHTML: (element)=>element.style.getPropertyValue('background-color') || null
-            },
-            colwidths: {
-                default: null,
-                renderHTML: (attributes)=>{
-                    if (!attributes['colwidths']) {
-                        return {}; // Nothing to render
-                    }
-                    return {
-                        'data-colwidths': JSON.stringify(attributes['colwidths'])
-                    };
-                },
-                parseHTML: (element)=>{
-                    // Only get cols from direct child colgroup (not from nested tables)
-                    const colgroup = element.querySelector(':scope > colgroup');
-                    if (!colgroup) return null;
-                    const cols = colgroup.querySelectorAll('col');
-                    if (cols.length === 0) return null;
-                    const colwidths = [];
-                    cols.forEach((col)=>{
-                        const width = col.getAttribute('style');
-                        if (width) {
-                            const match = width.match(/width:\s*(\d+(?:\.\d+)?)%/);
-                            colwidths.push(match ? parseFloat(match[1]) : null);
-                        } else {
-                            colwidths.push(null);
-                        }
-                    });
-                    return colwidths.length > 0 ? colwidths : null;
-                }
-            }
-        };
-    },
-    renderHTML ({ node, HTMLAttributes }) {
-        const colwidths = node.attrs?.['colwidths'];
-        const domNodes = [];
-        // Render <colgroup> when colwidths are present
-        if (colwidths) {
-            const colgroup = [
-                'colgroup',
-                {}
-            ];
-            colwidths.forEach((width)=>{
-                colgroup.push([
-                    'col',
-                    {
-                        style: width ? `width: ${width}%` : null
-                    }
-                ]);
-            });
-            domNodes.push(colgroup);
-        }
-        // Add <tbody> (0 is the 'content hole')
-        domNodes.push([
-            'tbody',
-            0
-        ]);
-        // Merge the HTML attributes (including global attributes)
-        // HTMLAttributes has already been merged by Tiptap via getRenderedAttributes
-        return [
-            'table',
-            HTMLAttributes,
-            ...domNodes
-        ];
-    },
-    addCommands () {
-        const parent = this.parent?.() ?? {};
-        return {
-            ...parent,
-            // Table
-            setTableBorder: (border)=>({ chain, state })=>{
-                    if (!border) return chain().focus().updateAttributes('table', {
-                        border: null
-                    }).run();
-                    // Get current table border and merge with new values
-                    // Find the table node
-                    const cellInfo = getCursorCellInfo(state);
-                    if (!cellInfo) return false;
-                    const currentBorder = cellInfo?.tableNode?.attrs?.['border'] || {};
-                    const mergedBorder = {
-                        style: border.style !== undefined ? border.style : currentBorder.style || null,
-                        color: border.color !== undefined ? border.color : currentBorder.color || null,
-                        width: border.width !== undefined ? border.width : currentBorder.width || null
-                    };
-                    return chain().focus().updateAttributes('table', {
-                        border: mergedBorder
-                    }).run();
-                },
-            setTableBackgroundColor: (color)=>({ chain })=>{
-                    return chain().focus().updateAttributes('table', {
-                        backgroundColor: color ?? null
-                    }).run();
-                },
-            insertTable: ({ rows, cols, withHeaderRow })=>({ tr, dispatch, editor })=>{
-                    const { schema } = editor.state;
-                    // --- STEP 1: Compute colWidths ---
-                    const calculatedColWidths = [];
-                    const defaultWidth = 100 / cols;
-                    for(let i = 0; i < cols; i += 1){
-                        calculatedColWidths.push(defaultWidth);
-                    }
-                    // Example: cols = 3 -> calculatedColWidths = [33.33, 33.33, 33.33]
-                    // --- STEP 2: Build the table content (rows, cells) ---
-                    // We have to build the child nodes ourselves
-                    const cellType = schema.nodes['tableCell'];
-                    const headerType = schema.nodes['tableHeader'];
-                    const rowType = schema.nodes['tableRow'];
-                    const tableRows = [];
-                    // Helper to create a single empty cell
-                    const createEmptyCell = (type)=>{
-                        const emptyParagraph = schema.nodes['paragraph'].create();
-                        return type.create(null, emptyParagraph);
-                    };
-                    // Create the rows
-                    for(let r = 0; r < rows; r += 1){
-                        const tableCells = [];
-                        for(let c = 0; c < cols; c += 1){
-                            let cellNode;
-                            // If this is the first row and 'withHeaderRow' is set
-                            if (r === 0 && withHeaderRow) {
-                                cellNode = createEmptyCell(headerType);
-                            } else {
-                                cellNode = createEmptyCell(cellType);
-                            }
-                            tableCells.push(cellNode);
-                        }
-                        // Add the new row to the rows array
-                        tableRows.push(rowType.create(null, tableCells));
-                    }
-                    // --- STEP 3: Create the main Table node WITH the 'colwidths' ATTRIBUTE ---
-                    const tableNode = schema.nodes['table'].create({
-                        // This is the key part: assign our percentage array here
-                        colwidths: calculatedColWidths
-                    }, tableRows // Content (the 'tableRow' nodes)
-                    );
-                    // --- STEP 4: Dispatch transaction (Original code)---
-                    if (dispatch) {
-                        const offset = tr.selection.from + 1;
-                        tr.replaceSelectionWith(tableNode).scrollIntoView().setSelection(TextSelection.near(tr.doc.resolve(offset)));
-                    }
-                    return true;
-                },
-            // 2. ADDCOLUMNAFTER COMMAND
-            addColumnAfter: ()=>({ state, dispatch })=>{
-                    const $cell = selectionCell(state);
-                    if (!$cell) return false;
-                    const table = $cell.node(-1);
-                    const tablePos = $cell.start(-1) - 1;
-                    const oldColWidths = table.attrs['colwidths'];
-                    // Calculate column index
-                    const map = TableMap.get(table);
-                    const cellPosInTable = $cell.pos - $cell.start(-1);
-                    const colIndex = map.colCount(cellPosInTable);
-                    // Calculate new column widths - ensure no column goes below MIN_NEW_COL_WIDTH
-                    const newColWidths = calculateColumnWidthsForNewColumn(oldColWidths);
-                    // Insert new column width
-                    newColWidths.splice(colIndex + 1, 0, MIN_NEW_COL_WIDTH);
-                    if (dispatch) {
-                        // Use the prosemirror-tables function directly to add column
-                        // This modifies the transaction but doesn't dispatch it
-                        addColumnAfter(state, (modifiedTr)=>{
-                            // Add our colwidth changes to the same transaction
-                            modifiedTr.setNodeMarkup(tablePos, null, {
-                                ...table.attrs,
-                                colwidths: newColWidths
-                            });
-                            // Now dispatch the complete transaction
-                            dispatch(modifiedTr.scrollIntoView());
-                        });
-                    }
-                    return true;
-                },
-            // 3. ADDCOLUMNBEFORE COMMAND
-            addColumnBefore: ()=>({ state, dispatch })=>{
-                    const $cell = selectionCell(state);
-                    if (!$cell) return false;
-                    const table = $cell.node(-1);
-                    const tablePos = $cell.start(-1) - 1;
-                    const oldColWidths = table.attrs['colwidths'];
-                    // Calculate column index
-                    const map = TableMap.get(table);
-                    const cellPosInTable = $cell.pos - $cell.start(-1);
-                    const colIndex = map.colCount(cellPosInTable);
-                    // Calculate new column widths - ensure no column goes below MIN_NEW_COL_WIDTH
-                    const newColWidths = calculateColumnWidthsForNewColumn(oldColWidths);
-                    // Insert new column width at current column index (before)
-                    newColWidths.splice(colIndex, 0, MIN_NEW_COL_WIDTH);
-                    if (dispatch) {
-                        addColumnBefore(state, (modifiedTr)=>{
-                            modifiedTr.setNodeMarkup(tablePos, null, {
-                                ...table.attrs,
-                                colwidths: newColWidths
-                            });
-                            dispatch(modifiedTr.scrollIntoView());
-                        });
-                    }
-                    return true;
-                },
-            // 4. DELETECOLUMN COMMAND
-            deleteColumn: ()=>({ state, dispatch })=>{
-                    const $cell = selectionCell(state);
-                    if (!$cell) return false;
-                    const table = $cell.node(-1);
-                    const tablePos = $cell.start(-1) - 1;
-                    const oldColWidths = table.attrs['colwidths'];
-                    // Calculate column index
-                    const map = TableMap.get(table);
-                    const cellPosInTable = $cell.pos - $cell.start(-1);
-                    const colIndex = map.colCount(cellPosInTable);
-                    // Get width of column being removed
-                    const removedWidth = oldColWidths[colIndex];
-                    // Create array of remaining columns
-                    const remainingWidths = oldColWidths.filter((_, i)=>i !== colIndex);
-                    // Distribute removed width among remaining columns
-                    const gainPerCol = removedWidth / remainingWidths.length;
-                    const newColWidths = remainingWidths.map((w)=>w + gainPerCol);
-                    if (dispatch) {
-                        deleteColumn(state, (modifiedTr)=>{
-                            modifiedTr.setNodeMarkup(tablePos, null, {
-                                ...table.attrs,
-                                colwidths: newColWidths
-                            });
-                            dispatch(modifiedTr.scrollIntoView());
-                        });
-                    }
-                    return true;
-                },
-            // Cell
-            setCellBorder: (border)=>({ chain, state })=>{
-                    if (!border) return chain().focus().updateAttributes('tableCell', {
-                        border: null
-                    }).updateAttributes('tableHeader', {
-                        border: null
-                    }).run();
-                    // Get current border and merge with new values
-                    const { selection } = state;
-                    const { $from } = selection;
-                    const cellPos = $from.node(-1);
-                    const currentBorder = cellPos?.attrs?.['border'] || {};
-                    const mergedBorder = {
-                        style: border.style ? border.style : currentBorder.style || null,
-                        color: border.color ? border.color : currentBorder.color || null,
-                        width: border.width ? border.width : currentBorder.width || null
-                    };
-                    return chain().focus().updateAttributes('tableCell', {
-                        border: mergedBorder
-                    }).updateAttributes('tableHeader', {
-                        border: mergedBorder
-                    }).run();
-                },
-            setCellVerticalAlign: (align)=>({ chain })=>{
-                    return chain().focus().updateAttributes('tableCell', {
-                        verticalAlign: align ?? null
-                    }).updateAttributes('tableHeader', {
-                        verticalAlign: align ?? null
-                    }).run();
-                },
-            setCellTextAlign: (align)=>({ chain })=>{
-                    return chain().focus().updateAttributes('tableCell', {
-                        textAlign: align ?? null
-                    }).updateAttributes('tableHeader', {
-                        textAlign: align ?? null
-                    }).run();
-                },
-            setCellBackgroundColor: (color)=>({ chain })=>{
-                    // Set all cells to the same background color
-                    return chain().focus().updateAttributes('tableCell', {
-                        backgroundColor: color ?? null
-                    }).updateAttributes('tableHeader', {
-                        backgroundColor: color ?? null
-                    }).run();
-                }
-        };
-    },
-    addNodeView () {
-        const options = this.options;
-        if (options.enableNodeView === false) {
-            return null;
-        }
-        // Only use custom NodeView (with handle) when editor is editable
-        return (props)=>{
-            // Check if editor is editable
-            if (!props.editor.isEditable) {
-                // Return undefined to use default table rendering (no widget wrapper)
-                return undefined;
-            }
-            // Editor is editable → use custom NodeView with handle
-            return createTableNodeView(props);
-        };
-    }
-});
-// Convenience export for consumers who want the full set
-export const StyledTableKit = Extension.create({
-    name: 'styledTableKit',
-    addExtensions () {
-        const extensions = [];
-        if (this.options.table !== false) {
-            extensions.push(StyledTable.configure({
-                ...this.options.table,
-                resizable: false
-            }));
-        }
-        if (this.options.tableRow !== false) {
-            extensions.push(TableRow.configure(this.options.tableRow));
-        }
-        if (this.options.tableHeader !== false) {
-            extensions.push(StyledTableHeader.configure(this.options.tableHeader));
-        }
-        if (this.options.tableCell !== false) {
-            extensions.push(StyledTableCell.configure(this.options.tableCell));
-        }
-        if (this.options.table?.resizable !== false) {
-            extensions.push(PercentageColumnResizing);
-        }
-        return extensions;
-    }
-});

package/src/extensions/text-case.extension.js

@@ -1,39 +0,0 @@
-import { Extension } from '@tiptap/core';
-import { TextSelection } from '@tiptap/pm/state';
-export const TextCase = Extension.create({
-    name: 'textCase',
-    addOptions () {
-        return {
-            type: 'uppercase'
-        };
-    },
-    addCommands () {
-        return {
-            textCase: (type)=>({ tr, state })=>{
-                    const { $from, $to, empty } = tr.selection;
-                    // If selection is empty, return false
-                    if (empty) return false;
-                    // If selection is not empty, get the text of the selection
-                    const text = state.doc.textBetween($from.pos, $to.pos, '\n', '\n');
-                    // If text is empty, return false
-                    if (text.length === 0) return false;
-                    let newText = text;
-                    // Change the text case
-                    switch(type){
-                        case 'uppercase':
-                            newText = text.toUpperCase();
-                            break;
-                        case 'lowercase':
-                            newText = text.toLowerCase();
-                            break;
-                        case 'capitalize':
-                            newText = text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
-                            break;
-                    }
-                    tr.replaceWith($from.pos, $to.pos, state.schema.text(newText));
-                    tr.setSelection(TextSelection.create(tr.doc, $from.pos, $from.pos + newText.length));
-                    return true;
-                }
-        };
-    }
-});