@vc-shell/framework 1.1.46 → 1.1.48

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

@@ -1,66 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,354 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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 };