@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-tiptap-extension-blockquote-jmWBTtsI.js

@@ -1,57 +0,0 @@
-import { N as Node, w as wrappingInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * Matches a blockquote to a `>` as input.
- */
-const inputRegex = /^\s*>\s$/;
-/**
- * This extension allows you to create blockquotes.
- * @see https://tiptap.dev/api/nodes/blockquote
- */
-const Blockquote = Node.create({
-    name: 'blockquote',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    content: 'block+',
-    group: 'block',
-    defining: true,
-    parseHTML() {
-        return [
-            { tag: 'blockquote' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['blockquote', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setBlockquote: () => ({ commands }) => {
-                return commands.wrapIn(this.name);
-            },
-            toggleBlockquote: () => ({ commands }) => {
-                return commands.toggleWrap(this.name);
-            },
-            unsetBlockquote: () => ({ commands }) => {
-                return commands.lift(this.name);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Shift-b': () => this.editor.commands.toggleBlockquote(),
-        };
-    },
-    addInputRules() {
-        return [
-            wrappingInputRule({
-                find: inputRegex,
-                type: this.type,
-            }),
-        ];
-    },
-});
-
-export { Blockquote as B };

package/dist/vendor-tiptap-extension-bold-p5frh4ak.js

@@ -1,97 +0,0 @@
-import { M as Mark, a as markPasteRule, b as markInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * Matches bold text via `**` as input.
- */
-const starInputRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
-/**
- * Matches bold text via `**` while pasting.
- */
-const starPasteRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
-/**
- * Matches bold text via `__` as input.
- */
-const underscoreInputRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
-/**
- * Matches bold text via `__` while pasting.
- */
-const underscorePasteRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
-/**
- * This extension allows you to mark text as bold.
- * @see https://tiptap.dev/api/marks/bold
- */
-const Bold = Mark.create({
-    name: 'bold',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: 'strong',
-            },
-            {
-                tag: 'b',
-                getAttrs: node => node.style.fontWeight !== 'normal' && null,
-            },
-            {
-                style: 'font-weight=400',
-                clearMark: mark => mark.type.name === this.name,
-            },
-            {
-                style: 'font-weight',
-                getAttrs: value => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null,
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['strong', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setBold: () => ({ commands }) => {
-                return commands.setMark(this.name);
-            },
-            toggleBold: () => ({ commands }) => {
-                return commands.toggleMark(this.name);
-            },
-            unsetBold: () => ({ commands }) => {
-                return commands.unsetMark(this.name);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-b': () => this.editor.commands.toggleBold(),
-            'Mod-B': () => this.editor.commands.toggleBold(),
-        };
-    },
-    addInputRules() {
-        return [
-            markInputRule({
-                find: starInputRegex,
-                type: this.type,
-            }),
-            markInputRule({
-                find: underscoreInputRegex,
-                type: this.type,
-            }),
-        ];
-    },
-    addPasteRules() {
-        return [
-            markPasteRule({
-                find: starPasteRegex,
-                type: this.type,
-            }),
-            markPasteRule({
-                find: underscorePasteRegex,
-                type: this.type,
-            }),
-        ];
-    },
-});
-
-export { Bold as B };

package/dist/vendor-tiptap-extension-bubble-menu-KUhZSfrs.js

@@ -1,218 +0,0 @@
-import { i as isTextSelection, c as isNodeSelection, p as posToDOMRect, E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
-import { t as tippy } from './vendor-tippy-js-DWFe2TfK.js';
-import { P as Plugin, a as PluginKey } from './vendor-prosemirror-state-BvL9Pxph.js';
-
-class BubbleMenuView {
-    constructor({ editor, element, view, tippyOptions = {}, updateDelay = 250, shouldShow, }) {
-        this.preventHide = false;
-        this.shouldShow = ({ view, state, from, to, }) => {
-            const { doc, selection } = state;
-            const { empty } = selection;
-            // Sometime check for `empty` is not enough.
-            // Doubleclick an empty paragraph returns a node size of 2.
-            // So we check also for an empty text size.
-            const isEmptyTextBlock = !doc.textBetween(from, to).length && isTextSelection(state.selection);
-            // When clicking on a element inside the bubble menu the editor "blur" event
-            // is called and the bubble menu item is focussed. In this case we should
-            // consider the menu as part of the editor and keep showing the menu
-            const isChildOfMenu = this.element.contains(document.activeElement);
-            const hasEditorFocus = view.hasFocus() || isChildOfMenu;
-            if (!hasEditorFocus || empty || isEmptyTextBlock || !this.editor.isEditable) {
-                return false;
-            }
-            return true;
-        };
-        this.mousedownHandler = () => {
-            this.preventHide = true;
-        };
-        this.dragstartHandler = () => {
-            this.hide();
-        };
-        this.focusHandler = () => {
-            // we use `setTimeout` to make sure `selection` is already updated
-            setTimeout(() => this.update(this.editor.view));
-        };
-        this.blurHandler = ({ event }) => {
-            var _a;
-            if (this.preventHide) {
-                this.preventHide = false;
-                return;
-            }
-            if ((event === null || event === void 0 ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) === null || _a === void 0 ? void 0 : _a.contains(event.relatedTarget))) {
-                return;
-            }
-            if ((event === null || event === void 0 ? void 0 : event.relatedTarget) === this.editor.view.dom) {
-                return;
-            }
-            this.hide();
-        };
-        this.tippyBlurHandler = (event) => {
-            this.blurHandler({ event });
-        };
-        this.handleDebouncedUpdate = (view, oldState) => {
-            const selectionChanged = !(oldState === null || oldState === void 0 ? void 0 : oldState.selection.eq(view.state.selection));
-            const docChanged = !(oldState === null || oldState === void 0 ? void 0 : oldState.doc.eq(view.state.doc));
-            if (!selectionChanged && !docChanged) {
-                return;
-            }
-            if (this.updateDebounceTimer) {
-                clearTimeout(this.updateDebounceTimer);
-            }
-            this.updateDebounceTimer = window.setTimeout(() => {
-                this.updateHandler(view, selectionChanged, docChanged, oldState);
-            }, this.updateDelay);
-        };
-        this.updateHandler = (view, selectionChanged, docChanged, oldState) => {
-            var _a, _b, _c;
-            const { state, composing } = view;
-            const { selection } = state;
-            const isSame = !selectionChanged && !docChanged;
-            if (composing || isSame) {
-                return;
-            }
-            this.createTooltip();
-            // support for CellSelections
-            const { ranges } = selection;
-            const from = Math.min(...ranges.map(range => range.$from.pos));
-            const to = Math.max(...ranges.map(range => range.$to.pos));
-            const shouldShow = (_a = this.shouldShow) === null || _a === void 0 ? void 0 : _a.call(this, {
-                editor: this.editor,
-                element: this.element,
-                view,
-                state,
-                oldState,
-                from,
-                to,
-            });
-            if (!shouldShow) {
-                this.hide();
-                return;
-            }
-            (_b = this.tippy) === null || _b === void 0 ? void 0 : _b.setProps({
-                getReferenceClientRect: ((_c = this.tippyOptions) === null || _c === void 0 ? void 0 : _c.getReferenceClientRect)
-                    || (() => {
-                        if (isNodeSelection(state.selection)) {
-                            let node = view.nodeDOM(from);
-                            if (node) {
-                                const nodeViewWrapper = node.dataset.nodeViewWrapper ? node : node.querySelector('[data-node-view-wrapper]');
-                                if (nodeViewWrapper) {
-                                    node = nodeViewWrapper.firstChild;
-                                }
-                                if (node) {
-                                    return node.getBoundingClientRect();
-                                }
-                            }
-                        }
-                        return posToDOMRect(view, from, to);
-                    }),
-            });
-            this.show();
-        };
-        this.editor = editor;
-        this.element = element;
-        this.view = view;
-        this.updateDelay = updateDelay;
-        if (shouldShow) {
-            this.shouldShow = shouldShow;
-        }
-        this.element.addEventListener('mousedown', this.mousedownHandler, { capture: true });
-        this.view.dom.addEventListener('dragstart', this.dragstartHandler);
-        this.editor.on('focus', this.focusHandler);
-        this.editor.on('blur', this.blurHandler);
-        this.tippyOptions = tippyOptions;
-        // Detaches menu content from its current parent
-        this.element.remove();
-        this.element.style.visibility = 'visible';
-    }
-    createTooltip() {
-        const { element: editorElement } = this.editor.options;
-        const editorIsAttached = !!editorElement.parentElement;
-        if (this.tippy || !editorIsAttached) {
-            return;
-        }
-        this.tippy = tippy(editorElement, {
-            duration: 0,
-            getReferenceClientRect: null,
-            content: this.element,
-            interactive: true,
-            trigger: 'manual',
-            placement: 'top',
-            hideOnClick: 'toggle',
-            ...this.tippyOptions,
-        });
-        // maybe we have to hide tippy on its own blur event as well
-        if (this.tippy.popper.firstChild) {
-            this.tippy.popper.firstChild.addEventListener('blur', this.tippyBlurHandler);
-        }
-    }
-    update(view, oldState) {
-        const { state } = view;
-        const hasValidSelection = state.selection.from !== state.selection.to;
-        if (this.updateDelay > 0 && hasValidSelection) {
-            this.handleDebouncedUpdate(view, oldState);
-            return;
-        }
-        const selectionChanged = !(oldState === null || oldState === void 0 ? void 0 : oldState.selection.eq(view.state.selection));
-        const docChanged = !(oldState === null || oldState === void 0 ? void 0 : oldState.doc.eq(view.state.doc));
-        this.updateHandler(view, selectionChanged, docChanged, oldState);
-    }
-    show() {
-        var _a;
-        (_a = this.tippy) === null || _a === void 0 ? void 0 : _a.show();
-    }
-    hide() {
-        var _a;
-        (_a = this.tippy) === null || _a === void 0 ? void 0 : _a.hide();
-    }
-    destroy() {
-        var _a, _b;
-        if ((_a = this.tippy) === null || _a === void 0 ? void 0 : _a.popper.firstChild) {
-            this.tippy.popper.firstChild.removeEventListener('blur', this.tippyBlurHandler);
-        }
-        (_b = this.tippy) === null || _b === void 0 ? void 0 : _b.destroy();
-        this.element.removeEventListener('mousedown', this.mousedownHandler, { capture: true });
-        this.view.dom.removeEventListener('dragstart', this.dragstartHandler);
-        this.editor.off('focus', this.focusHandler);
-        this.editor.off('blur', this.blurHandler);
-    }
-}
-const BubbleMenuPlugin = (options) => {
-    return new Plugin({
-        key: typeof options.pluginKey === 'string' ? new PluginKey(options.pluginKey) : options.pluginKey,
-        view: view => new BubbleMenuView({ view, ...options }),
-    });
-};
-
-/**
- * This extension allows you to create a bubble menu.
- * @see https://tiptap.dev/api/extensions/bubble-menu
- */
-Extension.create({
-    name: 'bubbleMenu',
-    addOptions() {
-        return {
-            element: null,
-            tippyOptions: {},
-            pluginKey: 'bubbleMenu',
-            updateDelay: undefined,
-            shouldShow: null,
-        };
-    },
-    addProseMirrorPlugins() {
-        if (!this.options.element) {
-            return [];
-        }
-        return [
-            BubbleMenuPlugin({
-                pluginKey: this.options.pluginKey,
-                editor: this.editor,
-                element: this.options.element,
-                tippyOptions: this.options.tippyOptions,
-                updateDelay: this.options.updateDelay,
-                shouldShow: this.options.shouldShow,
-            }),
-        ];
-    },
-});
-
-export { BubbleMenuPlugin as B };

package/dist/vendor-tiptap-extension-bullet-list-COmZRoSB.js

@@ -1,73 +0,0 @@
-import { N as Node, w as wrappingInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-const ListItemName = 'listItem';
-const TextStyleName = 'textStyle';
-/**
- * Matches a bullet list to a dash or asterisk.
- */
-const inputRegex = /^\s*([-+*])\s$/;
-/**
- * This extension allows you to create bullet lists.
- * This requires the ListItem extension
- * @see https://tiptap.dev/api/nodes/bullet-list
- * @see https://tiptap.dev/api/nodes/list-item.
- */
-const BulletList = Node.create({
-    name: 'bulletList',
-    addOptions() {
-        return {
-            itemTypeName: 'listItem',
-            HTMLAttributes: {},
-            keepMarks: false,
-            keepAttributes: false,
-        };
-    },
-    group: 'block list',
-    content() {
-        return `${this.options.itemTypeName}+`;
-    },
-    parseHTML() {
-        return [
-            { tag: 'ul' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            toggleBulletList: () => ({ commands, chain }) => {
-                if (this.options.keepAttributes) {
-                    return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
-                }
-                return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Shift-8': () => this.editor.commands.toggleBulletList(),
-        };
-    },
-    addInputRules() {
-        let inputRule = wrappingInputRule({
-            find: inputRegex,
-            type: this.type,
-        });
-        if (this.options.keepMarks || this.options.keepAttributes) {
-            inputRule = wrappingInputRule({
-                find: inputRegex,
-                type: this.type,
-                keepMarks: this.options.keepMarks,
-                keepAttributes: this.options.keepAttributes,
-                getAttributes: () => { return this.editor.getAttributes(TextStyleName); },
-                editor: this.editor,
-            });
-        }
-        return [
-            inputRule,
-        ];
-    },
-});
-
-export { BulletList as B };

package/dist/vendor-tiptap-extension-code-block-DyTARZss.js

@@ -1,221 +0,0 @@
-import { N as Node, t as textblockTypeInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-import { P as Plugin, a as PluginKey, T as TextSelection, S as Selection } from './vendor-prosemirror-state-BvL9Pxph.js';
-
-/**
- * Matches a code block with backticks.
- */
-const backtickInputRegex = /^```([a-z]+)?[\s\n]$/;
-/**
- * Matches a code block with tildes.
- */
-const tildeInputRegex = /^~~~([a-z]+)?[\s\n]$/;
-/**
- * This extension allows you to create code blocks.
- * @see https://tiptap.dev/api/nodes/code-block
- */
-const CodeBlock = Node.create({
-    name: 'codeBlock',
-    addOptions() {
-        return {
-            languageClassPrefix: 'language-',
-            exitOnTripleEnter: true,
-            exitOnArrowDown: true,
-            defaultLanguage: null,
-            HTMLAttributes: {},
-        };
-    },
-    content: 'text*',
-    marks: '',
-    group: 'block',
-    code: true,
-    defining: true,
-    addAttributes() {
-        return {
-            language: {
-                default: this.options.defaultLanguage,
-                parseHTML: element => {
-                    var _a;
-                    const { languageClassPrefix } = this.options;
-                    const classNames = [...(((_a = element.firstElementChild) === null || _a === void 0 ? void 0 : _a.classList) || [])];
-                    const languages = classNames
-                        .filter(className => className.startsWith(languageClassPrefix))
-                        .map(className => className.replace(languageClassPrefix, ''));
-                    const language = languages[0];
-                    if (!language) {
-                        return null;
-                    }
-                    return language;
-                },
-                rendered: false,
-            },
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: 'pre',
-                preserveWhitespace: 'full',
-            },
-        ];
-    },
-    renderHTML({ node, HTMLAttributes }) {
-        return [
-            'pre',
-            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
-            [
-                'code',
-                {
-                    class: node.attrs.language
-                        ? this.options.languageClassPrefix + node.attrs.language
-                        : null,
-                },
-                0,
-            ],
-        ];
-    },
-    addCommands() {
-        return {
-            setCodeBlock: attributes => ({ commands }) => {
-                return commands.setNode(this.name, attributes);
-            },
-            toggleCodeBlock: attributes => ({ commands }) => {
-                return commands.toggleNode(this.name, 'paragraph', attributes);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Alt-c': () => this.editor.commands.toggleCodeBlock(),
-            // remove code block when at start of document or code block is empty
-            Backspace: () => {
-                const { empty, $anchor } = this.editor.state.selection;
-                const isAtStart = $anchor.pos === 1;
-                if (!empty || $anchor.parent.type.name !== this.name) {
-                    return false;
-                }
-                if (isAtStart || !$anchor.parent.textContent.length) {
-                    return this.editor.commands.clearNodes();
-                }
-                return false;
-            },
-            // exit node on triple enter
-            Enter: ({ editor }) => {
-                if (!this.options.exitOnTripleEnter) {
-                    return false;
-                }
-                const { state } = editor;
-                const { selection } = state;
-                const { $from, empty } = selection;
-                if (!empty || $from.parent.type !== this.type) {
-                    return false;
-                }
-                const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
-                const endsWithDoubleNewline = $from.parent.textContent.endsWith('\n\n');
-                if (!isAtEnd || !endsWithDoubleNewline) {
-                    return false;
-                }
-                return editor
-                    .chain()
-                    .command(({ tr }) => {
-                    tr.delete($from.pos - 2, $from.pos);
-                    return true;
-                })
-                    .exitCode()
-                    .run();
-            },
-            // exit node on arrow down
-            ArrowDown: ({ editor }) => {
-                if (!this.options.exitOnArrowDown) {
-                    return false;
-                }
-                const { state } = editor;
-                const { selection, doc } = state;
-                const { $from, empty } = selection;
-                if (!empty || $from.parent.type !== this.type) {
-                    return false;
-                }
-                const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
-                if (!isAtEnd) {
-                    return false;
-                }
-                const after = $from.after();
-                if (after === undefined) {
-                    return false;
-                }
-                const nodeAfter = doc.nodeAt(after);
-                if (nodeAfter) {
-                    return editor.commands.command(({ tr }) => {
-                        tr.setSelection(Selection.near(doc.resolve(after)));
-                        return true;
-                    });
-                }
-                return editor.commands.exitCode();
-            },
-        };
-    },
-    addInputRules() {
-        return [
-            textblockTypeInputRule({
-                find: backtickInputRegex,
-                type: this.type,
-                getAttributes: match => ({
-                    language: match[1],
-                }),
-            }),
-            textblockTypeInputRule({
-                find: tildeInputRegex,
-                type: this.type,
-                getAttributes: match => ({
-                    language: match[1],
-                }),
-            }),
-        ];
-    },
-    addProseMirrorPlugins() {
-        return [
-            // this plugin creates a code block for pasted content from VS Code
-            // we can also detect the copied code language
-            new Plugin({
-                key: new PluginKey('codeBlockVSCodeHandler'),
-                props: {
-                    handlePaste: (view, event) => {
-                        if (!event.clipboardData) {
-                            return false;
-                        }
-                        // don’t create a new code block within code blocks
-                        if (this.editor.isActive(this.type.name)) {
-                            return false;
-                        }
-                        const text = event.clipboardData.getData('text/plain');
-                        const vscode = event.clipboardData.getData('vscode-editor-data');
-                        const vscodeData = vscode ? JSON.parse(vscode) : undefined;
-                        const language = vscodeData === null || vscodeData === void 0 ? void 0 : vscodeData.mode;
-                        if (!text || !language) {
-                            return false;
-                        }
-                        const { tr, schema } = view.state;
-                        // prepare a text node
-                        // strip carriage return chars from text pasted as code
-                        // see: https://github.com/ProseMirror/prosemirror-view/commit/a50a6bcceb4ce52ac8fcc6162488d8875613aacd
-                        const textNode = schema.text(text.replace(/\r\n?/g, '\n'));
-                        // create a code block with the text node
-                        // replace selection with the code block
-                        tr.replaceSelectionWith(this.type.create({ language }, textNode));
-                        if (tr.selection.$from.parent.type !== this.type) {
-                            // put cursor inside the newly created code block
-                            tr.setSelection(TextSelection.near(tr.doc.resolve(Math.max(0, tr.selection.from - 2))));
-                        }
-                        // store meta information
-                        // this is useful for other plugins that depends on the paste event
-                        // like the paste rule plugin
-                        tr.setMeta('paste', true);
-                        view.dispatch(tr);
-                        return true;
-                    },
-                },
-            }),
-        ];
-    },
-});
-
-export { CodeBlock as C };