@vc-shell/framework 1.1.43 → 1.1.45

package/dist/vendor-tiptap-extension-code-jVv6CXpX.js

@@ -0,0 +1,75 @@
+import { M as Mark, a as markPasteRule, b as markInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * Regular expressions to match inline code blocks enclosed in backticks.
+ *  It matches:
+ *     - An opening backtick, followed by
+ *     - Any text that doesn't include a backtick (captured for marking), followed by
+ *     - A closing backtick.
+ *  This ensures that any text between backticks is formatted as code,
+ *  regardless of the surrounding characters (exception being another backtick).
+ */
+const inputRegex = /(^|[^`])`([^`]+)`(?!`)/;
+/**
+ * Matches inline code while pasting.
+ */
+const pasteRegex = /(^|[^`])`([^`]+)`(?!`)/g;
+/**
+ * This extension allows you to mark text as inline code.
+ * @see https://tiptap.dev/api/marks/code
+ */
+const Code = Mark.create({
+    name: 'code',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    excludes: '_',
+    code: true,
+    exitable: true,
+    parseHTML() {
+        return [
+            { tag: 'code' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['code', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addCommands() {
+        return {
+            setCode: () => ({ commands }) => {
+                return commands.setMark(this.name);
+            },
+            toggleCode: () => ({ commands }) => {
+                return commands.toggleMark(this.name);
+            },
+            unsetCode: () => ({ commands }) => {
+                return commands.unsetMark(this.name);
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-e': () => this.editor.commands.toggleCode(),
+        };
+    },
+    addInputRules() {
+        return [
+            markInputRule({
+                find: inputRegex,
+                type: this.type,
+            }),
+        ];
+    },
+    addPasteRules() {
+        return [
+            markPasteRule({
+                find: pasteRegex,
+                type: this.type,
+            }),
+        ];
+    },
+});
+
+export { Code as C };

package/dist/vendor-tiptap-extension-document-DssuotYs.js

@@ -0,0 +1,13 @@
+import { N as Node } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * The default document node which represents the top level node of the editor.
+ * @see https://tiptap.dev/api/nodes/document
+ */
+const Document = Node.create({
+    name: 'doc',
+    topNode: true,
+    content: 'block+',
+});
+
+export { Document as D };

package/dist/vendor-tiptap-extension-dropcursor-BoO0Qv91.js

@@ -0,0 +1,26 @@
+import { E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
+import { d as dropCursor } from './vendor-prosemirror-dropcursor-CeyPcxrA.js';
+
+/**
+ * This extension allows you to add a drop cursor to your editor.
+ * A drop cursor is a line that appears when you drag and drop content
+ * inbetween nodes.
+ * @see https://tiptap.dev/api/extensions/dropcursor
+ */
+const Dropcursor = Extension.create({
+    name: 'dropCursor',
+    addOptions() {
+        return {
+            color: 'currentColor',
+            width: 1,
+            class: undefined,
+        };
+    },
+    addProseMirrorPlugins() {
+        return [
+            dropCursor(this.options),
+        ];
+    },
+});
+
+export { Dropcursor as D };

package/dist/vendor-tiptap-extension-floating-menu-CrO8CN5w.js

@@ -0,0 +1,165 @@
+import { g as getText, d as getTextSerializersFromSchema, 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 FloatingMenuView {
+    getTextContent(node) {
+        return getText(node, { textSerializers: getTextSerializersFromSchema(this.editor.schema) });
+    }
+    constructor({ editor, element, view, tippyOptions = {}, shouldShow, }) {
+        this.preventHide = false;
+        this.shouldShow = ({ view, state }) => {
+            const { selection } = state;
+            const { $anchor, empty } = selection;
+            const isRootDepth = $anchor.depth === 1;
+            const isEmptyTextBlock = $anchor.parent.isTextblock && !$anchor.parent.type.spec.code && !$anchor.parent.textContent && $anchor.parent.childCount === 0 && !this.getTextContent($anchor.parent);
+            if (!view.hasFocus()
+                || !empty
+                || !isRootDepth
+                || !isEmptyTextBlock
+                || !this.editor.isEditable) {
+                return false;
+            }
+            return true;
+        };
+        this.mousedownHandler = () => {
+            this.preventHide = true;
+        };
+        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.editor = editor;
+        this.element = element;
+        this.view = view;
+        if (shouldShow) {
+            this.shouldShow = shouldShow;
+        }
+        this.element.addEventListener('mousedown', this.mousedownHandler, { capture: true });
+        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: 'right',
+            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) {
+        var _a, _b, _c;
+        const { state } = view;
+        const { doc, selection } = state;
+        const { from, to } = selection;
+        const isSame = oldState && oldState.doc.eq(doc) && oldState.selection.eq(selection);
+        if (isSame) {
+            return;
+        }
+        this.createTooltip();
+        const shouldShow = (_a = this.shouldShow) === null || _a === void 0 ? void 0 : _a.call(this, {
+            editor: this.editor,
+            view,
+            state,
+            oldState,
+        });
+        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) || (() => posToDOMRect(view, from, to)),
+        });
+        this.show();
+    }
+    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.editor.off('focus', this.focusHandler);
+        this.editor.off('blur', this.blurHandler);
+    }
+}
+const FloatingMenuPlugin = (options) => {
+    return new Plugin({
+        key: typeof options.pluginKey === 'string' ? new PluginKey(options.pluginKey) : options.pluginKey,
+        view: view => new FloatingMenuView({ view, ...options }),
+    });
+};
+
+/**
+ * This extension allows you to create a floating menu.
+ * @see https://tiptap.dev/api/extensions/floating-menu
+ */
+Extension.create({
+    name: 'floatingMenu',
+    addOptions() {
+        return {
+            element: null,
+            tippyOptions: {},
+            pluginKey: 'floatingMenu',
+            shouldShow: null,
+        };
+    },
+    addProseMirrorPlugins() {
+        if (!this.options.element) {
+            return [];
+        }
+        return [
+            FloatingMenuPlugin({
+                pluginKey: this.options.pluginKey,
+                editor: this.editor,
+                element: this.options.element,
+                tippyOptions: this.options.tippyOptions,
+                shouldShow: this.options.shouldShow,
+            }),
+        ];
+    },
+});
+
+export { FloatingMenuPlugin as F };

package/dist/vendor-tiptap-extension-gapcursor-KpsWEoMD.js

@@ -0,0 +1,30 @@
+import { E as Extension, e as callOrReturn, f as getExtensionField } from './vendor-tiptap-core-NfwGfaQk.js';
+import { g as gapCursor } from './vendor-prosemirror-gapcursor-U8UoUJII.js';
+
+/**
+ * This extension allows you to add a gap cursor to your editor.
+ * A gap cursor is a cursor that appears when you click on a place
+ * where no content is present, for example inbetween nodes.
+ * @see https://tiptap.dev/api/extensions/gapcursor
+ */
+const Gapcursor = Extension.create({
+    name: 'gapCursor',
+    addProseMirrorPlugins() {
+        return [
+            gapCursor(),
+        ];
+    },
+    extendNodeSchema(extension) {
+        var _a;
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        return {
+            allowGapCursor: (_a = callOrReturn(getExtensionField(extension, 'allowGapCursor', context))) !== null && _a !== void 0 ? _a : null,
+        };
+    },
+});
+
+export { Gapcursor as G };

package/dist/vendor-tiptap-extension-hard-break-ldOzhSvf.js

@@ -0,0 +1,68 @@
+import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to insert hard breaks.
+ * @see https://www.tiptap.dev/api/nodes/hard-break
+ */
+const HardBreak = Node.create({
+    name: 'hardBreak',
+    addOptions() {
+        return {
+            keepMarks: true,
+            HTMLAttributes: {},
+        };
+    },
+    inline: true,
+    group: 'inline',
+    selectable: false,
+    linebreakReplacement: true,
+    parseHTML() {
+        return [
+            { tag: 'br' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['br', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    },
+    renderText() {
+        return '\n';
+    },
+    addCommands() {
+        return {
+            setHardBreak: () => ({ commands, chain, state, editor, }) => {
+                return commands.first([
+                    () => commands.exitCode(),
+                    () => commands.command(() => {
+                        const { selection, storedMarks } = state;
+                        if (selection.$from.parent.type.spec.isolating) {
+                            return false;
+                        }
+                        const { keepMarks } = this.options;
+                        const { splittableMarks } = editor.extensionManager;
+                        const marks = storedMarks
+                            || (selection.$to.parentOffset && selection.$from.marks());
+                        return chain()
+                            .insertContent({ type: this.name })
+                            .command(({ tr, dispatch }) => {
+                            if (dispatch && marks && keepMarks) {
+                                const filteredMarks = marks
+                                    .filter(mark => splittableMarks.includes(mark.type.name));
+                                tr.ensureMarks(filteredMarks);
+                            }
+                            return true;
+                        })
+                            .run();
+                    }),
+                ]);
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-Enter': () => this.editor.commands.setHardBreak(),
+            'Shift-Enter': () => this.editor.commands.setHardBreak(),
+        };
+    },
+});
+
+export { HardBreak as H };

package/dist/vendor-tiptap-extension-heading-CKz2llX0.js

@@ -0,0 +1,77 @@
+import { N as Node, t as textblockTypeInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * This extension allows you to create headings.
+ * @see https://www.tiptap.dev/api/nodes/heading
+ */
+const Heading = Node.create({
+    name: 'heading',
+    addOptions() {
+        return {
+            levels: [1, 2, 3, 4, 5, 6],
+            HTMLAttributes: {},
+        };
+    },
+    content: 'inline*',
+    group: 'block',
+    defining: true,
+    addAttributes() {
+        return {
+            level: {
+                default: 1,
+                rendered: false,
+            },
+        };
+    },
+    parseHTML() {
+        return this.options.levels
+            .map((level) => ({
+            tag: `h${level}`,
+            attrs: { level },
+        }));
+    },
+    renderHTML({ node, HTMLAttributes }) {
+        const hasLevel = this.options.levels.includes(node.attrs.level);
+        const level = hasLevel
+            ? node.attrs.level
+            : this.options.levels[0];
+        return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addCommands() {
+        return {
+            setHeading: attributes => ({ commands }) => {
+                if (!this.options.levels.includes(attributes.level)) {
+                    return false;
+                }
+                return commands.setNode(this.name, attributes);
+            },
+            toggleHeading: attributes => ({ commands }) => {
+                if (!this.options.levels.includes(attributes.level)) {
+                    return false;
+                }
+                return commands.toggleNode(this.name, 'paragraph', attributes);
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return this.options.levels.reduce((items, level) => ({
+            ...items,
+            ...{
+                [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level }),
+            },
+        }), {});
+    },
+    addInputRules() {
+        return this.options.levels.map(level => {
+            return textblockTypeInputRule({
+                find: new RegExp(`^(#{${Math.min(...this.options.levels)},${level}})\\s$`),
+                type: this.type,
+                getAttributes: {
+                    level,
+                },
+            });
+        });
+    },
+});
+
+export { Heading as H };

package/dist/vendor-tiptap-extension-history-DeKZ2VQ9.js

@@ -0,0 +1,48 @@
+import { E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
+import { h as history, r as redo, u as undo } from './vendor-prosemirror-history-BDaJkvNx.js';
+
+/**
+ * This extension allows you to undo and redo recent changes.
+ * @see https://www.tiptap.dev/api/extensions/history
+ *
+ * **Important**: If the `@tiptap/extension-collaboration` package is used, make sure to remove
+ * the `history` extension, as it is not compatible with the `collaboration` extension.
+ *
+ * `@tiptap/extension-collaboration` uses its own history implementation.
+ */
+const History = Extension.create({
+    name: 'history',
+    addOptions() {
+        return {
+            depth: 100,
+            newGroupDelay: 500,
+        };
+    },
+    addCommands() {
+        return {
+            undo: () => ({ state, dispatch }) => {
+                return undo(state, dispatch);
+            },
+            redo: () => ({ state, dispatch }) => {
+                return redo(state, dispatch);
+            },
+        };
+    },
+    addProseMirrorPlugins() {
+        return [
+            history(this.options),
+        ];
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-z': () => this.editor.commands.undo(),
+            'Shift-Mod-z': () => this.editor.commands.redo(),
+            'Mod-y': () => this.editor.commands.redo(),
+            // Russian keyboard layouts
+            'Mod-я': () => this.editor.commands.undo(),
+            'Shift-Mod-я': () => this.editor.commands.redo(),
+        };
+    },
+});
+
+export { History as H };

package/dist/vendor-tiptap-extension-horizontal-rule-CAjWRyDS.js

@@ -0,0 +1,92 @@
+import { N as Node, n as nodeInputRule, h as canInsertNode, c as isNodeSelection, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+import { T as TextSelection, N as NodeSelection } from './vendor-prosemirror-state-BvL9Pxph.js';
+
+/**
+ * This extension allows you to insert horizontal rules.
+ * @see https://www.tiptap.dev/api/nodes/horizontal-rule
+ */
+const HorizontalRule = Node.create({
+    name: 'horizontalRule',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    group: 'block',
+    parseHTML() {
+        return [{ tag: 'hr' }];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['hr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    },
+    addCommands() {
+        return {
+            setHorizontalRule: () => ({ chain, state }) => {
+                // Check if we can insert the node at the current selection
+                if (!canInsertNode(state, state.schema.nodes[this.name])) {
+                    return false;
+                }
+                const { selection } = state;
+                const { $from: $originFrom, $to: $originTo } = selection;
+                const currentChain = chain();
+                if ($originFrom.parentOffset === 0) {
+                    currentChain.insertContentAt({
+                        from: Math.max($originFrom.pos - 1, 0),
+                        to: $originTo.pos,
+                    }, {
+                        type: this.name,
+                    });
+                }
+                else if (isNodeSelection(selection)) {
+                    currentChain.insertContentAt($originTo.pos, {
+                        type: this.name,
+                    });
+                }
+                else {
+                    currentChain.insertContent({ type: this.name });
+                }
+                return (currentChain
+                    // set cursor after horizontal rule
+                    .command(({ tr, dispatch }) => {
+                    var _a;
+                    if (dispatch) {
+                        const { $to } = tr.selection;
+                        const posAfter = $to.end();
+                        if ($to.nodeAfter) {
+                            if ($to.nodeAfter.isTextblock) {
+                                tr.setSelection(TextSelection.create(tr.doc, $to.pos + 1));
+                            }
+                            else if ($to.nodeAfter.isBlock) {
+                                tr.setSelection(NodeSelection.create(tr.doc, $to.pos));
+                            }
+                            else {
+                                tr.setSelection(TextSelection.create(tr.doc, $to.pos));
+                            }
+                        }
+                        else {
+                            // add node after horizontal rule if it’s the end of the document
+                            const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();
+                            if (node) {
+                                tr.insert(posAfter, node);
+                                tr.setSelection(TextSelection.create(tr.doc, posAfter + 1));
+                            }
+                        }
+                        tr.scrollIntoView();
+                    }
+                    return true;
+                })
+                    .run());
+            },
+        };
+    },
+    addInputRules() {
+        return [
+            nodeInputRule({
+                find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+                type: this.type,
+            }),
+        ];
+    },
+});
+
+export { HorizontalRule as H };

package/dist/vendor-tiptap-extension-image-ZagcEYuk.js

@@ -0,0 +1,76 @@
+import { N as Node, n as nodeInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
+
+/**
+ * Matches an image to a ![image](src "title") on input.
+ */
+const inputRegex = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/;
+/**
+ * This extension allows you to insert images.
+ * @see https://www.tiptap.dev/api/nodes/image
+ */
+const Image = Node.create({
+    name: 'image',
+    addOptions() {
+        return {
+            inline: false,
+            allowBase64: false,
+            HTMLAttributes: {},
+        };
+    },
+    inline() {
+        return this.options.inline;
+    },
+    group() {
+        return this.options.inline ? 'inline' : 'block';
+    },
+    draggable: true,
+    addAttributes() {
+        return {
+            src: {
+                default: null,
+            },
+            alt: {
+                default: null,
+            },
+            title: {
+                default: null,
+            },
+        };
+    },
+    parseHTML() {
+        return [
+            {
+                tag: this.options.allowBase64
+                    ? 'img[src]'
+                    : 'img[src]:not([src^="data:"])',
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['img', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    },
+    addCommands() {
+        return {
+            setImage: options => ({ commands }) => {
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: options,
+                });
+            },
+        };
+    },
+    addInputRules() {
+        return [
+            nodeInputRule({
+                find: inputRegex,
+                type: this.type,
+                getAttributes: match => {
+                    const [, , alt, src, title] = match;
+                    return { src, alt, title };
+                },
+            }),
+        ];
+    },
+});
+
+export { Image as I };