@vc-shell/framework 1.1.44 → 1.1.46

package/dist/vendor-tiptap-extension-placeholder-BBNVKfa_.js

@@ -0,0 +1,66 @@
+import { E as Extension, r as isNodeEmpty } from './vendor-tiptap-core-NfwGfaQk.js';
+import { a as Decoration, D as DecorationSet } from './vendor-prosemirror-view-CU2WTHT7.js';
+import { P as Plugin, a as PluginKey } from './vendor-prosemirror-state-BvL9Pxph.js';
+
+/**
+ * This extension allows you to add a placeholder to your editor.
+ * A placeholder is a text that appears when the editor or a node is empty.
+ * @see https://www.tiptap.dev/api/extensions/placeholder
+ */
+const Placeholder = Extension.create({
+    name: 'placeholder',
+    addOptions() {
+        return {
+            emptyEditorClass: 'is-editor-empty',
+            emptyNodeClass: 'is-empty',
+            placeholder: 'Write something …',
+            showOnlyWhenEditable: true,
+            showOnlyCurrent: true,
+            includeChildren: false,
+        };
+    },
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey('placeholder'),
+                props: {
+                    decorations: ({ doc, selection }) => {
+                        const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;
+                        const { anchor } = selection;
+                        const decorations = [];
+                        if (!active) {
+                            return null;
+                        }
+                        const isEmptyDoc = this.editor.isEmpty;
+                        doc.descendants((node, pos) => {
+                            const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
+                            const isEmpty = !node.isLeaf && isNodeEmpty(node);
+                            if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
+                                const classes = [this.options.emptyNodeClass];
+                                if (isEmptyDoc) {
+                                    classes.push(this.options.emptyEditorClass);
+                                }
+                                const decoration = Decoration.node(pos, pos + node.nodeSize, {
+                                    class: classes.join(' '),
+                                    'data-placeholder': typeof this.options.placeholder === 'function'
+                                        ? this.options.placeholder({
+                                            editor: this.editor,
+                                            node,
+                                            pos,
+                                            hasAnchor,
+                                        })
+                                        : this.options.placeholder,
+                                });
+                                decorations.push(decoration);
+                            }
+                            return this.options.includeChildren;
+                        });
+                        return DecorationSet.create(doc, decorations);
+                    },
+                },
+            }),
+        ];
+    },
+});
+
+export { Placeholder as P };

package/dist/vendor-tiptap-extension-strike-DUyMYX1Z.js

@@ -0,0 +1,79 @@
+import { M as Mark, a as markPasteRule, b as markInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * Matches a strike to a ~~strike~~ on input.
+ */
+const inputRegex = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/;
+/**
+ * Matches a strike to a ~~strike~~ on paste.
+ */
+const pasteRegex = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g;
+/**
+ * This extension allows you to create strike text.
+ * @see https://www.tiptap.dev/api/marks/strike
+ */
+const Strike = Mark.create({
+    name: 'strike',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    parseHTML() {
+        return [
+            {
+                tag: 's',
+            },
+            {
+                tag: 'del',
+            },
+            {
+                tag: 'strike',
+            },
+            {
+                style: 'text-decoration',
+                consuming: false,
+                getAttrs: style => (style.includes('line-through') ? {} : false),
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['s', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addCommands() {
+        return {
+            setStrike: () => ({ commands }) => {
+                return commands.setMark(this.name);
+            },
+            toggleStrike: () => ({ commands }) => {
+                return commands.toggleMark(this.name);
+            },
+            unsetStrike: () => ({ commands }) => {
+                return commands.unsetMark(this.name);
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-Shift-s': () => this.editor.commands.toggleStrike(),
+        };
+    },
+    addInputRules() {
+        return [
+            markInputRule({
+                find: inputRegex,
+                type: this.type,
+            }),
+        ];
+    },
+    addPasteRules() {
+        return [
+            markPasteRule({
+                find: pasteRegex,
+                type: this.type,
+            }),
+        ];
+    },
+});
+
+export { Strike as S };

package/dist/vendor-tiptap-extension-table-cell-CoDIMPA5.js

@@ -0,0 +1,47 @@
+import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create table cells.
+ * @see https://www.tiptap.dev/api/nodes/table-cell
+ */
+const TableCell = Node.create({
+    name: 'tableCell',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    content: 'block+',
+    addAttributes() {
+        return {
+            colspan: {
+                default: 1,
+            },
+            rowspan: {
+                default: 1,
+            },
+            colwidth: {
+                default: null,
+                parseHTML: element => {
+                    const colwidth = element.getAttribute('colwidth');
+                    const value = colwidth
+                        ? colwidth.split(',').map(width => parseInt(width, 10))
+                        : null;
+                    return value;
+                },
+            },
+        };
+    },
+    tableRole: 'cell',
+    isolating: true,
+    parseHTML() {
+        return [
+            { tag: 'td' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['td', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+});
+
+export { TableCell as T };

package/dist/vendor-tiptap-extension-table-header-DvbGHnmw.js

@@ -0,0 +1,47 @@
+import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create table headers.
+ * @see https://www.tiptap.dev/api/nodes/table-header
+ */
+const TableHeader = Node.create({
+    name: 'tableHeader',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    content: 'block+',
+    addAttributes() {
+        return {
+            colspan: {
+                default: 1,
+            },
+            rowspan: {
+                default: 1,
+            },
+            colwidth: {
+                default: null,
+                parseHTML: element => {
+                    const colwidth = element.getAttribute('colwidth');
+                    const value = colwidth
+                        ? colwidth.split(',').map(width => parseInt(width, 10))
+                        : null;
+                    return value;
+                },
+            },
+        };
+    },
+    tableRole: 'header_cell',
+    isolating: true,
+    parseHTML() {
+        return [
+            { tag: 'th' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['th', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+});
+
+export { TableHeader as T };

package/dist/vendor-tiptap-extension-table-row-D1uqN5Aj.js

@@ -0,0 +1,26 @@
+import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create table rows.
+ * @see https://www.tiptap.dev/api/nodes/table-row
+ */
+const TableRow = Node.create({
+    name: 'tableRow',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    content: '(tableCell | tableHeader)*',
+    tableRole: 'row',
+    parseHTML() {
+        return [
+            { tag: 'tr' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['tr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+});
+
+export { TableRow as T };

package/dist/vendor-tiptap-extension-table-tKS4MOM4.js

@@ -0,0 +1,354 @@
+import { N as Node, e as callOrReturn, f as getExtensionField, m as mergeAttributes, s as findParentNodeClosestToPos } from './vendor-tiptap-core-NfwGfaQk.js';
+import { c as columnResizing, t as tableEditing, C as CellSelection, f as fixTables, g as goToNextCell, s as setCellAttr, m as mergeCells, a as splitCell, b as toggleHeaderCell, d as toggleHeader, e as deleteTable, h as deleteRow, i as addRowAfter, j as addRowBefore, k as deleteColumn, l as addColumnAfter, n as addColumnBefore } from './vendor-prosemirror-tables-17qAnviK.js';
+import { T as TextSelection } from './vendor-prosemirror-state-BvL9Pxph.js';
+
+function getColStyleDeclaration(minWidth, width) {
+    if (width) {
+        // apply the stored width unless it is below the configured minimum cell width
+        return ['width', `${Math.max(width, minWidth)}px`];
+    }
+    // set the minimum with on the column if it has no stored width
+    return ['min-width', `${minWidth}px`];
+}
+
+function updateColumns(node, colgroup, // <colgroup> has the same prototype as <col>
+table, cellMinWidth, overrideCol, overrideValue) {
+    var _a;
+    let totalWidth = 0;
+    let fixedWidth = true;
+    let nextDOM = colgroup.firstChild;
+    const row = node.firstChild;
+    if (row !== null) {
+        for (let i = 0, col = 0; i < row.childCount; i += 1) {
+            const { colspan, colwidth } = row.child(i).attrs;
+            for (let j = 0; j < colspan; j += 1, col += 1) {
+                const hasWidth = overrideCol === col ? overrideValue : (colwidth && colwidth[j]);
+                const cssWidth = hasWidth ? `${hasWidth}px` : '';
+                totalWidth += hasWidth || cellMinWidth;
+                if (!hasWidth) {
+                    fixedWidth = false;
+                }
+                if (!nextDOM) {
+                    const colElement = document.createElement('col');
+                    const [propertyKey, propertyValue] = getColStyleDeclaration(cellMinWidth, hasWidth);
+                    colElement.style.setProperty(propertyKey, propertyValue);
+                    colgroup.appendChild(colElement);
+                }
+                else {
+                    if (nextDOM.style.width !== cssWidth) {
+                        const [propertyKey, propertyValue] = getColStyleDeclaration(cellMinWidth, hasWidth);
+                        nextDOM.style.setProperty(propertyKey, propertyValue);
+                    }
+                    nextDOM = nextDOM.nextSibling;
+                }
+            }
+        }
+    }
+    while (nextDOM) {
+        const after = nextDOM.nextSibling;
+        (_a = nextDOM.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(nextDOM);
+        nextDOM = after;
+    }
+    if (fixedWidth) {
+        table.style.width = `${totalWidth}px`;
+        table.style.minWidth = '';
+    }
+    else {
+        table.style.width = '';
+        table.style.minWidth = `${totalWidth}px`;
+    }
+}
+class TableView {
+    constructor(node, cellMinWidth) {
+        this.node = node;
+        this.cellMinWidth = cellMinWidth;
+        this.dom = document.createElement('div');
+        this.dom.className = 'tableWrapper';
+        this.table = this.dom.appendChild(document.createElement('table'));
+        this.colgroup = this.table.appendChild(document.createElement('colgroup'));
+        updateColumns(node, this.colgroup, this.table, cellMinWidth);
+        this.contentDOM = this.table.appendChild(document.createElement('tbody'));
+    }
+    update(node) {
+        if (node.type !== this.node.type) {
+            return false;
+        }
+        this.node = node;
+        updateColumns(node, this.colgroup, this.table, this.cellMinWidth);
+        return true;
+    }
+    ignoreMutation(mutation) {
+        return (mutation.type === 'attributes'
+            && (mutation.target === this.table || this.colgroup.contains(mutation.target)));
+    }
+}
+
+function createColGroup(node, cellMinWidth, overrideCol, overrideValue) {
+    let totalWidth = 0;
+    let fixedWidth = true;
+    const cols = [];
+    const row = node.firstChild;
+    if (!row) {
+        return {};
+    }
+    for (let i = 0, col = 0; i < row.childCount; i += 1) {
+        const { colspan, colwidth } = row.child(i).attrs;
+        for (let j = 0; j < colspan; j += 1, col += 1) {
+            const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];
+            totalWidth += hasWidth || cellMinWidth;
+            if (!hasWidth) {
+                fixedWidth = false;
+            }
+            const [property, value] = getColStyleDeclaration(cellMinWidth, hasWidth);
+            cols.push([
+                'col',
+                { style: `${property}: ${value}` },
+            ]);
+        }
+    }
+    const tableWidth = fixedWidth ? `${totalWidth}px` : '';
+    const tableMinWidth = fixedWidth ? '' : `${totalWidth}px`;
+    const colgroup = ['colgroup', {}, ...cols];
+    return { colgroup, tableWidth, tableMinWidth };
+}
+
+function createCell(cellType, cellContent) {
+    return cellType.createAndFill();
+}
+
+function getTableNodeTypes(schema) {
+    if (schema.cached.tableNodeTypes) {
+        return schema.cached.tableNodeTypes;
+    }
+    const roles = {};
+    Object.keys(schema.nodes).forEach(type => {
+        const nodeType = schema.nodes[type];
+        if (nodeType.spec.tableRole) {
+            roles[nodeType.spec.tableRole] = nodeType;
+        }
+    });
+    schema.cached.tableNodeTypes = roles;
+    return roles;
+}
+
+function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
+    const types = getTableNodeTypes(schema);
+    const headerCells = [];
+    const cells = [];
+    for (let index = 0; index < colsCount; index += 1) {
+        const cell = createCell(types.cell);
+        if (cell) {
+            cells.push(cell);
+        }
+        if (withHeaderRow) {
+            const headerCell = createCell(types.header_cell);
+            if (headerCell) {
+                headerCells.push(headerCell);
+            }
+        }
+    }
+    const rows = [];
+    for (let index = 0; index < rowsCount; index += 1) {
+        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+    }
+    return types.table.createChecked(null, rows);
+}
+
+function isCellSelection(value) {
+    return value instanceof CellSelection;
+}
+
+const deleteTableWhenAllCellsSelected = ({ editor }) => {
+    const { selection } = editor.state;
+    if (!isCellSelection(selection)) {
+        return false;
+    }
+    let cellCount = 0;
+    const table = findParentNodeClosestToPos(selection.ranges[0].$from, node => {
+        return node.type.name === 'table';
+    });
+    table === null || table === void 0 ? void 0 : table.node.descendants(node => {
+        if (node.type.name === 'table') {
+            return false;
+        }
+        if (['tableCell', 'tableHeader'].includes(node.type.name)) {
+            cellCount += 1;
+        }
+    });
+    const allCellsSelected = cellCount === selection.ranges.length;
+    if (!allCellsSelected) {
+        return false;
+    }
+    editor.commands.deleteTable();
+    return true;
+};
+
+/**
+ * This extension allows you to create tables.
+ * @see https://www.tiptap.dev/api/nodes/table
+ */
+const Table = Node.create({
+    name: 'table',
+    // @ts-ignore
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+            resizable: false,
+            handleWidth: 5,
+            cellMinWidth: 25,
+            // TODO: fix
+            View: TableView,
+            lastColumnResizable: true,
+            allowTableNodeSelection: false,
+        };
+    },
+    content: 'tableRow+',
+    tableRole: 'table',
+    isolating: true,
+    group: 'block',
+    parseHTML() {
+        return [{ tag: 'table' }];
+    },
+    renderHTML({ node, HTMLAttributes }) {
+        const { colgroup, tableWidth, tableMinWidth } = createColGroup(node, this.options.cellMinWidth);
+        const table = [
+            'table',
+            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+                style: tableWidth
+                    ? `width: ${tableWidth}`
+                    : `min-width: ${tableMinWidth}`,
+            }),
+            colgroup,
+            ['tbody', 0],
+        ];
+        return table;
+    },
+    addCommands() {
+        return {
+            insertTable: ({ rows = 3, cols = 3, withHeaderRow = true } = {}) => ({ tr, dispatch, editor }) => {
+                const node = createTable(editor.schema, rows, cols, withHeaderRow);
+                if (dispatch) {
+                    const offset = tr.selection.from + 1;
+                    tr.replaceSelectionWith(node)
+                        .scrollIntoView()
+                        .setSelection(TextSelection.near(tr.doc.resolve(offset)));
+                }
+                return true;
+            },
+            addColumnBefore: () => ({ state, dispatch }) => {
+                return addColumnBefore(state, dispatch);
+            },
+            addColumnAfter: () => ({ state, dispatch }) => {
+                return addColumnAfter(state, dispatch);
+            },
+            deleteColumn: () => ({ state, dispatch }) => {
+                return deleteColumn(state, dispatch);
+            },
+            addRowBefore: () => ({ state, dispatch }) => {
+                return addRowBefore(state, dispatch);
+            },
+            addRowAfter: () => ({ state, dispatch }) => {
+                return addRowAfter(state, dispatch);
+            },
+            deleteRow: () => ({ state, dispatch }) => {
+                return deleteRow(state, dispatch);
+            },
+            deleteTable: () => ({ state, dispatch }) => {
+                return deleteTable(state, dispatch);
+            },
+            mergeCells: () => ({ state, dispatch }) => {
+                return mergeCells(state, dispatch);
+            },
+            splitCell: () => ({ state, dispatch }) => {
+                return splitCell(state, dispatch);
+            },
+            toggleHeaderColumn: () => ({ state, dispatch }) => {
+                return toggleHeader('column')(state, dispatch);
+            },
+            toggleHeaderRow: () => ({ state, dispatch }) => {
+                return toggleHeader('row')(state, dispatch);
+            },
+            toggleHeaderCell: () => ({ state, dispatch }) => {
+                return toggleHeaderCell(state, dispatch);
+            },
+            mergeOrSplit: () => ({ state, dispatch }) => {
+                if (mergeCells(state, dispatch)) {
+                    return true;
+                }
+                return splitCell(state, dispatch);
+            },
+            setCellAttribute: (name, value) => ({ state, dispatch }) => {
+                return setCellAttr(name, value)(state, dispatch);
+            },
+            goToNextCell: () => ({ state, dispatch }) => {
+                return goToNextCell(1)(state, dispatch);
+            },
+            goToPreviousCell: () => ({ state, dispatch }) => {
+                return goToNextCell(-1)(state, dispatch);
+            },
+            fixTables: () => ({ state, dispatch }) => {
+                if (dispatch) {
+                    fixTables(state);
+                }
+                return true;
+            },
+            setCellSelection: position => ({ tr, dispatch }) => {
+                if (dispatch) {
+                    const selection = CellSelection.create(tr.doc, position.anchorCell, position.headCell);
+                    // @ts-ignore
+                    tr.setSelection(selection);
+                }
+                return true;
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            Tab: () => {
+                if (this.editor.commands.goToNextCell()) {
+                    return true;
+                }
+                if (!this.editor.can().addRowAfter()) {
+                    return false;
+                }
+                return this.editor.chain().addRowAfter().goToNextCell().run();
+            },
+            'Shift-Tab': () => this.editor.commands.goToPreviousCell(),
+            Backspace: deleteTableWhenAllCellsSelected,
+            'Mod-Backspace': deleteTableWhenAllCellsSelected,
+            Delete: deleteTableWhenAllCellsSelected,
+            'Mod-Delete': deleteTableWhenAllCellsSelected,
+        };
+    },
+    addProseMirrorPlugins() {
+        const isResizable = this.options.resizable && this.editor.isEditable;
+        return [
+            ...(isResizable
+                ? [
+                    columnResizing({
+                        handleWidth: this.options.handleWidth,
+                        cellMinWidth: this.options.cellMinWidth,
+                        defaultCellMinWidth: this.options.cellMinWidth,
+                        View: this.options.View,
+                        lastColumnResizable: this.options.lastColumnResizable,
+                    }),
+                ]
+                : []),
+            tableEditing({
+                allowTableNodeSelection: this.options.allowTableNodeSelection,
+            }),
+        ];
+    },
+    extendNodeSchema(extension) {
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        return {
+            tableRole: callOrReturn(getExtensionField(extension, 'tableRole', context)),
+        };
+    },
+});
+
+export { Table as T };

package/dist/vendor-tiptap-extension-text-DtRBhKB2.js

@@ -0,0 +1,12 @@
+import { N as Node } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create text nodes.
+ * @see https://www.tiptap.dev/api/nodes/text
+ */
+const Text = Node.create({
+    name: 'text',
+    group: 'inline',
+});
+
+export { Text as T };

package/dist/vendor-tiptap-extension-underline-DqaSFp_P.js

@@ -0,0 +1,50 @@
+import { M as Mark, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create underline text.
+ * @see https://www.tiptap.dev/api/marks/underline
+ */
+const Underline = Mark.create({
+    name: 'underline',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    parseHTML() {
+        return [
+            {
+                tag: 'u',
+            },
+            {
+                style: 'text-decoration',
+                consuming: false,
+                getAttrs: style => (style.includes('underline') ? {} : false),
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['u', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addCommands() {
+        return {
+            setUnderline: () => ({ commands }) => {
+                return commands.setMark(this.name);
+            },
+            toggleUnderline: () => ({ commands }) => {
+                return commands.toggleMark(this.name);
+            },
+            unsetUnderline: () => ({ commands }) => {
+                return commands.unsetMark(this.name);
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-u': () => this.editor.commands.toggleUnderline(),
+            'Mod-U': () => this.editor.commands.toggleUnderline(),
+        };
+    },
+});
+
+export { Underline as U };