@vc-shell/framework 1.1.43 → 1.1.45

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

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

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

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

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

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