@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/behavior/SelectionContext/index.js

@@ -0,0 +1,104 @@
+import { keydownHandler } from 'prosemirror-keymap';
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { isCodeBlock } from '../../../utils/nodes';
+import { TooltipView } from './tooltip';
+export const SelectionContext = (builder, { config }) => {
+    if (Array.isArray(config) && config.length > 0) {
+        builder.addPlugin(({ actions }) => new Plugin(new SelectionTooltip(actions, config)));
+    }
+};
+class SelectionTooltip {
+    constructor(actions, menuConfig) {
+        this.destroyed = false;
+        this.hideTimeoutRef = null;
+        this._isMousePressed = false;
+        this.tooltip = new TooltipView(actions, menuConfig);
+    }
+    get props() {
+        return {
+            // same as keymap({})
+            handleKeyDown: keydownHandler({
+                // hide context menu when Esc was pressed
+                Escape: (_state, _dispatch, view) => {
+                    if (this.tooltip.isTooltipOpen) {
+                        this.tooltip.hide(view);
+                        return true;
+                    }
+                    return false;
+                },
+            }),
+            handleDOMEvents: {
+                mousedown: (view) => {
+                    this._isMousePressed = true;
+                    this.cancelTooltipHiding();
+                    this.tooltip.hide(view);
+                    const onMouseUp = () => {
+                        if (this.destroyed)
+                            return;
+                        this._isMousePressed = false;
+                        this.update(view, this._prevState);
+                    };
+                    document.addEventListener('mouseup', onMouseUp, { once: true });
+                },
+            },
+        };
+    }
+    view(view) {
+        this.update(view);
+        return {
+            update: this.update.bind(this),
+            destroy: () => {
+                this.destroyed = true;
+                this.cancelTooltipHiding();
+                this.tooltip.destroy();
+            },
+        };
+    }
+    update(view, prevState) {
+        this._prevState = prevState;
+        if (this._isMousePressed)
+            return;
+        this._prevState = null;
+        this.cancelTooltipHiding();
+        // Don't show tooltip if editor not mounted to the DOM
+        // or when view is out of focus
+        if (!view.dom.parentNode || !view.hasFocus()) {
+            this.tooltip.hide(view);
+            return;
+        }
+        const { state } = view;
+        // Don't do anything if the document/selection didn't change
+        if (prevState && prevState.doc.eq(state.doc) && prevState.selection.eq(state.selection))
+            return;
+        const { selection } = state;
+        // Hide the tooltip if the selection is empty
+        if (selection.empty || !(selection instanceof TextSelection)) {
+            this.tooltip.hide(view);
+            return;
+        }
+        // Hide the tooltip when one side of selection inside codeblock
+        if (isCodeBlock(selection.$from.parent) || isCodeBlock(selection.$to.parent)) {
+            this.tooltip.hide(view);
+            return;
+        }
+        this.tooltip.show(view, {
+            onOutsideClick: () => {
+                this.scheduleTooltipHiding(view);
+            },
+        });
+    }
+    scheduleTooltipHiding(view) {
+        this.hideTimeoutRef = setTimeout(() => {
+            // hide tooltip if view is out of focus after 30 ms
+            if (!view.hasFocus()) {
+                this.tooltip.hide(view);
+            }
+        }, 30);
+    }
+    cancelTooltipHiding() {
+        if (this.hideTimeoutRef !== null) {
+            clearTimeout(this.hideTimeoutRef);
+            this.hideTimeoutRef = null;
+        }
+    }
+}

package/build/esm/extensions/behavior/SelectionContext/tooltip.d.ts

@@ -0,0 +1,29 @@
+import { PopupProps } from '@gravity-ui/uikit';
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { ActionStorage } from '../../../core';
+import { ToolbarGroupItemData } from '../../../toolbar';
+export declare type ContextGroupItemData = ToolbarGroupItemData<ActionStorage> & {
+    condition?: (state: EditorState) => void;
+};
+export declare type ContextGroupData = ContextGroupItemData[];
+export declare type ContextConfig = ContextGroupData[];
+export declare class TooltipView {
+    #private;
+    private actions;
+    private menuConfig;
+    private view;
+    private baseProps;
+    private _tooltipRenderItem;
+    constructor(actions: ActionStorage, menuConfig: ContextConfig);
+    get isTooltipOpen(): boolean;
+    show(view: EditorView, popupProps?: PopupProps): void;
+    hide(view: EditorView): void;
+    destroy(): void;
+    private getSelectionTooltipProps;
+    private getFilteredConfig;
+    private renderPopup;
+    private get tooltipRenderItem();
+    private calcPosition;
+    private get popupTextOffset();
+}

package/build/esm/extensions/behavior/SelectionContext/tooltip.js

@@ -0,0 +1,93 @@
+var _TooltipView_isTooltipOpen;
+import { __classPrivateFieldGet, __classPrivateFieldSet, __rest } from "tslib";
+import React from 'react';
+import { Popup } from '@gravity-ui/uikit';
+import { isFunction } from '../../../lodash';
+import { logger } from '../../../logger';
+import { ErrorLoggerBoundary } from '../../../react-utils/ErrorBoundary';
+import { Toolbar } from '../../../toolbar';
+import { getReactRendererFromState } from '../ReactRenderer';
+const SelectionTooltip = (_a) => {
+    var { show, poppupProps } = _a, toolbarProps = __rest(_a, ["show", "poppupProps"]);
+    if (!show)
+        return null;
+    return (React.createElement(Popup, Object.assign({ open: true }, poppupProps, { style: { padding: '4px 8px' } }),
+        React.createElement(Toolbar, Object.assign({}, toolbarProps))));
+};
+export class TooltipView {
+    constructor(actions, menuConfig) {
+        _TooltipView_isTooltipOpen.set(this, false);
+        this.baseProps = { show: false, poppupProps: {} };
+        this._tooltipRenderItem = null;
+        this.actions = actions;
+        this.menuConfig = menuConfig;
+    }
+    get isTooltipOpen() {
+        return __classPrivateFieldGet(this, _TooltipView_isTooltipOpen, "f");
+    }
+    show(view, popupProps) {
+        this.view = view;
+        __classPrivateFieldSet(this, _TooltipView_isTooltipOpen, true, "f");
+        this.baseProps = {
+            show: true,
+            poppupProps: Object.assign(Object.assign({}, popupProps), this.calcPosition(view)),
+        };
+        this.renderPopup();
+    }
+    hide(view) {
+        this.view = view;
+        __classPrivateFieldSet(this, _TooltipView_isTooltipOpen, false, "f");
+        this.baseProps = { show: false, poppupProps: {} };
+        this.renderPopup();
+    }
+    destroy() {
+        var _a;
+        (_a = this._tooltipRenderItem) === null || _a === void 0 ? void 0 : _a.remove();
+        this._tooltipRenderItem = null;
+    }
+    getSelectionTooltipProps() {
+        return Object.assign(Object.assign({}, this.baseProps), { focus: () => this.view.focus(), data: this.getFilteredConfig(), editor: this.actions, onClick: (id) => logger.action({ mode: 'wysiwyg', source: 'context-menu', action: id }) });
+    }
+    getFilteredConfig() {
+        return this.baseProps.show
+            ? this.menuConfig
+                .map((groupData) => groupData.filter(({ condition }) => isFunction(condition) ? condition(this.view.state) : true))
+                .filter((groupData) => Boolean(groupData.length))
+            : [];
+    }
+    renderPopup() {
+        this.tooltipRenderItem.rerender();
+    }
+    get tooltipRenderItem() {
+        if (!this._tooltipRenderItem) {
+            const reactRenderer = getReactRendererFromState(this.view.state);
+            this._tooltipRenderItem = reactRenderer.createItem('selection_context', () => (React.createElement(ErrorLoggerBoundary, null,
+                React.createElement(SelectionTooltip, Object.assign({}, this.getSelectionTooltipProps())))));
+        }
+        return this._tooltipRenderItem;
+    }
+    calcPosition(view) {
+        const viewDom = view.dom;
+        // The box in which the tooltip is positioned, to use as base
+        const viewBox = viewDom.getBoundingClientRect();
+        const viewWidth = viewBox.right - viewBox.left;
+        const viewHalfWidth = viewWidth / 2;
+        // These are in screen coordinates
+        const start = view.coordsAtPos(view.state.selection.from);
+        const end = view.coordsAtPos(view.state.selection.to);
+        // Find a center-ish x position from the selection endpoints (when
+        // crossing lines, end may be more to the left)
+        const left = Math.max((start.left + end.left) / 2, start.left + 3);
+        const leftOffset = left - (viewBox.left + viewHalfWidth);
+        const bottomOffset = -(viewBox.bottom - end.bottom) + this.popupTextOffset;
+        return {
+            placement: 'bottom',
+            anchorRef: { current: viewDom },
+            offset: [leftOffset, bottomOffset],
+        };
+    }
+    get popupTextOffset() {
+        return 4; // 4px offset from text selection
+    }
+}
+_TooltipView_isTooltipOpen = new WeakMap();

package/build/esm/extensions/behavior/WidgetDecoration/ReactWidgetDescriptor.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+import { RendererItem } from '../ReactRenderer';
+import { WidgetDescriptor } from './WidgetDescriptor';
+export declare abstract class ReactWidgetDescriptor extends WidgetDescriptor {
+    protected renderItem?: RendererItem;
+    abstract getDomElem(): HTMLElement;
+    abstract renderReactElement(view: EditorView, getPos: () => number): React.ReactElement;
+    remove(): void;
+    protected renderWidget(): HTMLElement;
+    protected createRenderItem(): RendererItem;
+}

package/build/esm/extensions/behavior/WidgetDecoration/ReactWidgetDescriptor.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { createPortal } from 'react-dom';
+import { ErrorLoggerBoundary } from '../../../react-utils/ErrorBoundary';
+import { getReactRendererFromState } from '../ReactRenderer';
+import { WidgetDescriptor } from './WidgetDescriptor';
+export class ReactWidgetDescriptor extends WidgetDescriptor {
+    remove() {
+        var _a;
+        (_a = this.renderItem) === null || _a === void 0 ? void 0 : _a.remove();
+        this.renderItem = undefined;
+    }
+    renderWidget() {
+        var _a;
+        this.renderItem = (_a = this.renderItem) !== null && _a !== void 0 ? _a : this.createRenderItem();
+        this.renderItem.rerender();
+        return this.getDomElem();
+    }
+    createRenderItem() {
+        return getReactRendererFromState(this.view.state).createItem('widget', () => createPortal(React.createElement(ErrorLoggerBoundary, null, this.renderReactElement(this.view, this.getPos)), this.getDomElem()));
+    }
+}

package/build/esm/extensions/behavior/WidgetDecoration/WidgetDescriptor.d.ts

@@ -0,0 +1,16 @@
+import { Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+export declare abstract class WidgetDescriptor {
+    #private;
+    abstract remove(): void;
+    protected abstract renderWidget(view: EditorView, getPos: () => number): HTMLElement;
+    get id(): string;
+    get initPos(): number;
+    protected get view(): EditorView | undefined;
+    protected get getPos(): (() => number) | undefined;
+    get pos(): number;
+    constructor(initPos: number, idPrefix?: string);
+    render(view: EditorView, getPos: () => number): HTMLElement;
+    applyTo(tr: Transaction): Transaction;
+    rmDeco(tr: Transaction): Transaction;
+}

package/build/esm/extensions/behavior/WidgetDecoration/WidgetDescriptor.js

@@ -0,0 +1,47 @@
+var _WidgetDescriptor_id, _WidgetDescriptor_initPos, _WidgetDescriptor_view, _WidgetDescriptor_getPos;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { uniqueId } from '../../../lodash';
+import { removeDecoration } from './actions';
+import { widgetDecorationPluginKey } from './plugin';
+export class WidgetDescriptor {
+    constructor(initPos, idPrefix) {
+        _WidgetDescriptor_id.set(this, void 0);
+        _WidgetDescriptor_initPos.set(this, void 0);
+        _WidgetDescriptor_view.set(this, void 0);
+        _WidgetDescriptor_getPos.set(this, void 0);
+        __classPrivateFieldSet(this, _WidgetDescriptor_id, uniqueId(idPrefix), "f");
+        __classPrivateFieldSet(this, _WidgetDescriptor_initPos, initPos, "f");
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _WidgetDescriptor_id, "f");
+    }
+    get initPos() {
+        return __classPrivateFieldGet(this, _WidgetDescriptor_initPos, "f");
+    }
+    get view() {
+        return __classPrivateFieldGet(this, _WidgetDescriptor_view, "f");
+    }
+    get getPos() {
+        return __classPrivateFieldGet(this, _WidgetDescriptor_getPos, "f");
+    }
+    get pos() {
+        var _a, _b;
+        return (_b = (_a = this.getPos) === null || _a === void 0 ? void 0 : _a.call(this)) !== null && _b !== void 0 ? _b : this.initPos;
+    }
+    render(view, getPos) {
+        __classPrivateFieldSet(this, _WidgetDescriptor_view, view, "f");
+        __classPrivateFieldSet(this, _WidgetDescriptor_getPos, getPos, "f");
+        return this.renderWidget(view, getPos);
+    }
+    applyTo(tr) {
+        const meta = {
+            type: 'add',
+            descriptor: this,
+        };
+        return tr.setMeta(widgetDecorationPluginKey, meta);
+    }
+    rmDeco(tr) {
+        return removeDecoration(tr, this.id);
+    }
+}
+_WidgetDescriptor_id = new WeakMap(), _WidgetDescriptor_initPos = new WeakMap(), _WidgetDescriptor_view = new WeakMap(), _WidgetDescriptor_getPos = new WeakMap();

package/build/esm/extensions/behavior/WidgetDecoration/actions.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare const removeDecoration: (tr: Transaction, id: string) => Transaction;

package/build/esm/extensions/behavior/WidgetDecoration/actions.js

@@ -0,0 +1,8 @@
+import { widgetDecorationPluginKey } from './plugin';
+export const removeDecoration = (tr, id) => {
+    const meta = {
+        type: 'remove',
+        id,
+    };
+    return tr.setMeta(widgetDecorationPluginKey, meta);
+};

package/build/esm/extensions/behavior/WidgetDecoration/index.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionAuto } from '../../../core';
+export { removeDecoration } from './actions';
+export { widgetDecorationPluginKey } from './plugin';
+export { WidgetDescriptor } from './WidgetDescriptor';
+export { ReactWidgetDescriptor } from './ReactWidgetDescriptor';
+export declare const WidgetDecoration: ExtensionAuto;

package/build/esm/extensions/behavior/WidgetDecoration/index.js

@@ -0,0 +1,8 @@
+import { WidgetDecorationPlugin } from './plugin';
+export { removeDecoration } from './actions';
+export { widgetDecorationPluginKey } from './plugin';
+export { WidgetDescriptor } from './WidgetDescriptor';
+export { ReactWidgetDescriptor } from './ReactWidgetDescriptor';
+export const WidgetDecoration = (builder) => {
+    builder.addPlugin(WidgetDecorationPlugin);
+};

package/build/esm/extensions/behavior/WidgetDecoration/plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+export declare const widgetDecorationPluginKey: PluginKey<DecorationSet>;
+export declare const WidgetDecorationPlugin: () => Plugin<DecorationSet>;

package/build/esm/extensions/behavior/WidgetDecoration/plugin.js

@@ -0,0 +1,47 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+export const widgetDecorationPluginKey = new PluginKey();
+export const WidgetDecorationPlugin = () => {
+    return new Plugin({
+        key: widgetDecorationPluginKey,
+        props: {
+            decorations(state) {
+                var _a;
+                return (_a = widgetDecorationPluginKey.getState(state)) !== null && _a !== void 0 ? _a : null;
+            },
+        },
+        state: {
+            init() {
+                return DecorationSet.empty;
+            },
+            apply(tr, oldSet) {
+                // Adjust decoration positions to changes made by the transaction
+                let set = oldSet.map(tr.mapping, tr.doc, {
+                    onRemove(spec) {
+                        const { descriptor } = spec;
+                        descriptor.remove();
+                    },
+                });
+                const meta = tr.getMeta(widgetDecorationPluginKey);
+                if ((meta === null || meta === void 0 ? void 0 : meta.type) === 'add') {
+                    const { descriptor } = meta;
+                    const spec = {
+                        id: descriptor.id,
+                        pos: descriptor.initPos,
+                        descriptor,
+                    };
+                    const deco = Decoration.widget(descriptor.initPos, 
+                    // @ts-expect-error
+                    descriptor.render.bind(descriptor), spec);
+                    set = set.add(tr.doc, [deco]);
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.type) === 'remove') {
+                    const decos = set.find(undefined, undefined, (spec) => spec.id === meta.id);
+                    decos.forEach((deco) => deco.spec.descriptor.remove());
+                    set = set.remove(decos);
+                }
+                return set;
+            },
+        },
+    });
+};

package/build/esm/extensions/behavior/WidgetDecoration/types.d.ts

@@ -0,0 +1,13 @@
+import type { WidgetDescriptor } from './WidgetDescriptor';
+export declare type Meta = {
+    type: 'add';
+    descriptor: WidgetDescriptor;
+} | {
+    type: 'remove';
+    id: string;
+};
+export declare type WidgetSpec = {
+    id: string;
+    descriptor: WidgetDescriptor;
+    pos: number;
+};

package/build/esm/extensions/behavior/WidgetDecoration/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/extensions/behavior/index.d.ts

@@ -0,0 +1,29 @@
+import type { ExtensionAuto } from '../../core';
+import { PlaceholderOptions } from '../../utils/placeholder';
+import { ClipboardOptions } from './Clipboard';
+import { CommandMenuOptions } from './CommandMenu';
+import { CursorOptions } from './Cursor';
+import { HistoryOptions } from './History';
+import { ReactRenderer } from './ReactRenderer';
+import { SelectionContextOptions } from './SelectionContext';
+export * from './ClicksOnEdges';
+export * from './Clipboard';
+export * from './CommandMenu';
+export * from './Cursor';
+export * from './FilePaste';
+export * from './History';
+export * from './Placeholder';
+export * from './ReactRenderer';
+export * from './Selection';
+export * from './SelectionContext';
+export * from './WidgetDecoration';
+export declare type BehaviorPresetOptions = {
+    cursor?: CursorOptions;
+    history?: HistoryOptions;
+    clipboard?: ClipboardOptions;
+    placeholder?: PlaceholderOptions;
+    reactRenderer: ReactRenderer;
+    selectionContext?: SelectionContextOptions;
+    commandMenu?: CommandMenuOptions;
+};
+export declare const BehaviorPreset: ExtensionAuto<BehaviorPresetOptions>;

package/build/esm/extensions/behavior/index.js

@@ -0,0 +1,38 @@
+import { ClicksOnEdges } from './ClicksOnEdges';
+import { Clipboard } from './Clipboard';
+import { CommandMenu } from './CommandMenu';
+import { Cursor } from './Cursor';
+import { FilePaste } from './FilePaste';
+import { History } from './History';
+import { Placeholder } from './Placeholder';
+import { ReactRendererExtension } from './ReactRenderer';
+import { Selection } from './Selection';
+import { SelectionContext } from './SelectionContext';
+import { WidgetDecoration } from './WidgetDecoration';
+export * from './ClicksOnEdges';
+export * from './Clipboard';
+export * from './CommandMenu';
+export * from './Cursor';
+export * from './FilePaste';
+export * from './History';
+export * from './Placeholder';
+export * from './ReactRenderer';
+export * from './Selection';
+export * from './SelectionContext';
+export * from './WidgetDecoration';
+export const BehaviorPreset = (builder, opts) => {
+    var _a, _b, _c, _d, _e;
+    builder
+        .use(Selection)
+        .use(Placeholder, (_a = opts.placeholder) !== null && _a !== void 0 ? _a : {})
+        .use(Cursor, (_b = opts.cursor) !== null && _b !== void 0 ? _b : {})
+        .use(History, (_c = opts.history) !== null && _c !== void 0 ? _c : {})
+        .use(Clipboard, (_d = opts.clipboard) !== null && _d !== void 0 ? _d : {})
+        .use(ReactRendererExtension, opts.reactRenderer)
+        .use(WidgetDecoration)
+        .use(SelectionContext, (_e = opts.selectionContext) !== null && _e !== void 0 ? _e : {});
+    if (opts.commandMenu)
+        builder.use(CommandMenu, opts.commandMenu);
+    builder.use(FilePaste);
+    builder.use(ClicksOnEdges);
+};

package/build/esm/extensions/behavior/utils/upload.d.ts

@@ -0,0 +1,17 @@
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { FileUploadHandler, UploadSuccessItem } from '../../../utils/upload';
+import type { WidgetDescriptor } from '../WidgetDecoration';
+export declare abstract class FilesBatchUploadProcess {
+    protected readonly view: EditorView;
+    protected readonly files: readonly File[];
+    protected readonly uploadHandler: FileUploadHandler;
+    protected skeletonDescriptor?: WidgetDescriptor;
+    constructor(view: EditorView, files: readonly File[], uploadHandler: FileUploadHandler);
+    run(): Promise<void>;
+    protected insertSkeleton(): Promise<void>;
+    protected abstract createSkeleton(): WidgetDescriptor | Promise<WidgetDescriptor>;
+    protected batchUpload(): Promise<void>;
+    protected abstract createPMNode(res: UploadSuccessItem): Promise<Node>;
+    protected removeSkeleton(): void;
+}

package/build/esm/extensions/behavior/utils/upload.js

@@ -0,0 +1,43 @@
+import { batchUploadFiles } from '../../../utils/upload';
+export class FilesBatchUploadProcess {
+    constructor(view, files, uploadHandler) {
+        this.view = view;
+        this.files = files;
+        this.uploadHandler = uploadHandler;
+    }
+    async run() {
+        await this.insertSkeleton();
+        await this.batchUpload();
+        this.removeSkeleton();
+    }
+    async insertSkeleton() {
+        const { view } = this;
+        const { state } = view;
+        this.skeletonDescriptor = await this.createSkeleton();
+        let tr = state.tr;
+        if (!state.selection.empty)
+            tr = tr.deleteSelection();
+        tr = this.skeletonDescriptor.applyTo(tr);
+        view.dispatch(tr);
+    }
+    async batchUpload() {
+        const insertQueue = [];
+        await batchUploadFiles(this.files, this.uploadHandler, (res) => {
+            insertQueue.push((async () => {
+                const node = await this.createPMNode(res);
+                const { view } = this;
+                const { schema } = view.state;
+                view.dispatch(view.state.tr.insert(this.skeletonDescriptor.pos, [
+                    schema.text(' '),
+                    node,
+                    schema.text(' '),
+                ]));
+            })().catch(console.error));
+        });
+        await Promise.allSettled(insertQueue);
+    }
+    removeSkeleton() {
+        const { view } = this;
+        view.dispatch(this.skeletonDescriptor.rmDeco(view.state.tr));
+    }
+}

package/build/esm/extensions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './behavior';
+export * from './markdown';
+export * from './yfm';

package/build/esm/extensions/index.js

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './behavior';
+export * from './markdown';
+export * from './yfm';

package/build/esm/extensions/markdown/Blockquote/BlockquoteSpecs/index.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export declare const blockquoteNodeName = "blockquote";
+export declare const blockquoteType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const isBlockqouteNode: (node: Node) => boolean;
+export declare const BlockquoteSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Blockquote/BlockquoteSpecs/index.js

@@ -0,0 +1,21 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export const blockquoteNodeName = 'blockquote';
+export const blockquoteType = nodeTypeFactory(blockquoteNodeName);
+export const isBlockqouteNode = (node) => node.type.name === blockquoteNodeName;
+export const BlockquoteSpecs = (builder) => {
+    builder.addNode(blockquoteNodeName, () => ({
+        spec: {
+            content: 'block+',
+            group: 'block',
+            defining: true,
+            parseDOM: [{ tag: 'blockquote' }],
+            toDOM() {
+                return ['blockquote', 0];
+            },
+        },
+        fromMd: { tokenSpec: { name: blockquoteNodeName, type: 'block' } },
+        toMd: (state, node) => {
+            state.wrapBlock('> ', null, node, () => state.renderContent(node));
+        },
+    }));
+};

package/build/esm/extensions/markdown/Blockquote/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from 'prosemirror-state';
+import '../../../types/spec';
+export declare const liftFromQuote: Command;
+export declare const joinPrevQuote: Command;
+export declare const toggleQuote: Command;

package/build/esm/extensions/markdown/Blockquote/commands.js

@@ -0,0 +1,46 @@
+import { lift, wrapIn } from 'prosemirror-commands';
+import { joinPreviousBlock } from '../../../commands/join';
+import '../../../types/spec';
+import { get$CursorAtBlockStart, isTextSelection } from '../../../utils/selection';
+import { bqType, isBlockqouteNode } from './const';
+export const liftFromQuote = (state, dispatch) => {
+    const $cursor = get$CursorAtBlockStart(state.selection);
+    if (!$cursor || !isBlockqouteNode($cursor.node(-1)))
+        return false;
+    return lift(state, dispatch);
+};
+export const joinPrevQuote = joinPreviousBlock({
+    checkPrevNode: isBlockqouteNode,
+    skipNode: isBlockqouteNode,
+});
+export const toggleQuote = (state, dispatch) => {
+    const { selection } = state;
+    const qType = bqType(state.schema);
+    if (!isTextSelection(selection) || !selection.$cursor)
+        return wrapIn(qType)(state, dispatch);
+    const { $cursor } = selection;
+    let { depth } = $cursor;
+    while (depth > 0) {
+        const node = $cursor.node(depth);
+        const nodeSpec = node.type.spec;
+        if (!nodeSpec.complex || nodeSpec.complex === 'root') {
+            const targetDepth = depth - 1;
+            const range = getBlockRange($cursor, depth);
+            if (isBlockqouteNode($cursor.node(targetDepth))) {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.lift(range, targetDepth - 1).scrollIntoView());
+            }
+            else {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.wrap(range, [{ type: qType }]).scrollIntoView());
+            }
+            return true;
+        }
+        depth--;
+    }
+    return false;
+};
+function getBlockRange($pos, depth) {
+    const { doc } = $pos;
+    const $before = doc.resolve($pos.before(depth));
+    const $after = doc.resolve($pos.after(depth));
+    return $before.blockRange($after);
+}