@gravity-ui/markdown-editor 13.0.0

package/build/cjs/extensions/behavior/CommandMenu/handler.d.ts

@@ -0,0 +1,33 @@
+import type { ActionStorage } from '../../../core';
+import { AutocompleteAction, AutocompleteHandler } from '../Autocomplete';
+import type { Config } from './types';
+declare module 'prosemirror-model' {
+    interface NodeSpec {
+        commandMenu?: boolean;
+    }
+}
+export declare type CommandHandlerParams = {
+    actions: Config;
+    storage: ActionStorage;
+    nodesIgnoreList?: readonly string[];
+};
+export declare class CommandHandler implements AutocompleteHandler {
+    #private;
+    constructor({ actions, storage, nodesIgnoreList }: CommandHandlerParams);
+    onOpen(action: AutocompleteAction): boolean;
+    onFilter(action: AutocompleteAction): boolean;
+    onArrow(action: AutocompleteAction): boolean;
+    onEnter(action: AutocompleteAction): boolean;
+    onClose(action: AutocompleteAction): boolean;
+    onDestroy(): void;
+    private closeAutocomplete;
+    private shouldIgnore;
+    private select;
+    private filterActions;
+    private render;
+    private onItemClick;
+    private updateState;
+    private clear;
+    private createMenuRenderItem;
+    private findAnchor;
+}

package/build/cjs/extensions/behavior/CommandMenu/handler.js

@@ -0,0 +1,206 @@
+"use strict";
+var _CommandHandler_actions, _CommandHandler_actionStorage, _CommandHandler_nodesIgnoreList, _CommandHandler_filteredActionsCarousel, _CommandHandler_view, _CommandHandler_anchor, _CommandHandler_range, _CommandHandler_filterText, _CommandHandler_popupCloser, _CommandHandler_menuProps, _CommandHandler_menuRenderItem;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandler = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = require("../../..//logger");
+const autocomplete_popup_1 = require("../../..//utils/autocomplete-popup");
+const carousel_1 = require("../../..//utils/carousel");
+const lodash_1 = require("../../../lodash");
+const Autocomplete_1 = require("../Autocomplete");
+const ReactRenderer_1 = require("../ReactRenderer");
+const component_1 = require("./component");
+const utils_1 = require("./utils");
+class CommandHandler {
+    constructor({ actions, storage, nodesIgnoreList = [] }) {
+        _CommandHandler_actions.set(this, void 0);
+        _CommandHandler_actionStorage.set(this, void 0);
+        _CommandHandler_nodesIgnoreList.set(this, void 0);
+        _CommandHandler_filteredActionsCarousel.set(this, void 0);
+        _CommandHandler_view.set(this, void 0);
+        _CommandHandler_anchor.set(this, void 0);
+        _CommandHandler_range.set(this, void 0);
+        _CommandHandler_filterText.set(this, void 0);
+        _CommandHandler_popupCloser.set(this, void 0);
+        _CommandHandler_menuProps.set(this, void 0);
+        _CommandHandler_menuRenderItem.set(this, void 0);
+        this.onItemClick = (index) => {
+            var _a;
+            if (tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f")) {
+                tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f").currentIndex = index;
+                this.select();
+            }
+            (_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_view, "f")) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_actions, actions, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_actionStorage, storage, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_nodesIgnoreList, nodesIgnoreList, "f");
+    }
+    onOpen(action) {
+        this.findAnchor();
+        if (!tslib_1.__classPrivateFieldGet(this, _CommandHandler_anchor, "f") || this.shouldIgnore(action)) {
+            this.closeAutocomplete(action.view);
+            return true;
+        }
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_popupCloser, new autocomplete_popup_1.AutocompletePopupCloser(action.view), "f");
+        this.updateState(action);
+        this.filterActions();
+        this.render();
+        return true;
+    }
+    onFilter(action) {
+        var _a, _b;
+        if (this.shouldIgnore(action) || ((_a = action.filter) === null || _a === void 0 ? void 0 : _a.endsWith('  '))) {
+            this.closeAutocomplete(action.view);
+            return true;
+        }
+        this.updateState(action);
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_filterText, (_b = action.filter) === null || _b === void 0 ? void 0 : _b.trim().toLowerCase(), "f");
+        const needToClose = this.filterActions();
+        this.render();
+        if (needToClose) {
+            this.closeAutocomplete(action.view);
+        }
+        return true;
+    }
+    onArrow(action) {
+        if (this.shouldIgnore(action)) {
+            (0, Autocomplete_1.closeAutocomplete)(action.view);
+            return true;
+        }
+        this.updateState(action);
+        if (!tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f"))
+            return false;
+        switch (action.kind) {
+            case Autocomplete_1.AutocompleteActionKind.up: {
+                tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f").prev();
+                break;
+            }
+            case Autocomplete_1.AutocompleteActionKind.down: {
+                tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f").next();
+                break;
+            }
+            default:
+                return false;
+        }
+        this.render();
+        return true;
+    }
+    onEnter(action) {
+        if (this.shouldIgnore(action)) {
+            (0, Autocomplete_1.closeAutocomplete)(action.view);
+            return true;
+        }
+        this.updateState(action);
+        this.select();
+        return true;
+    }
+    onClose(action) {
+        this.updateState(action);
+        this.clear();
+        return true;
+    }
+    onDestroy() {
+        this.clear();
+    }
+    closeAutocomplete(view) {
+        setTimeout(() => {
+            (0, Autocomplete_1.closeAutocomplete)(view);
+        });
+    }
+    shouldIgnore(action) {
+        const parentType = action.view.state.doc.resolve(action.range.from).parent.type;
+        return (parentType.spec.commandMenu === false || tslib_1.__classPrivateFieldGet(this, _CommandHandler_nodesIgnoreList, "f").includes(parentType.name));
+    }
+    select() {
+        var _a;
+        if (!tslib_1.__classPrivateFieldGet(this, _CommandHandler_view, "f") || !tslib_1.__classPrivateFieldGet(this, _CommandHandler_range, "f"))
+            return;
+        const action = (_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f")) === null || _a === void 0 ? void 0 : _a.currentItem;
+        if (!action)
+            return;
+        const view = tslib_1.__classPrivateFieldGet(this, _CommandHandler_view, "f");
+        const range = tslib_1.__classPrivateFieldGet(this, _CommandHandler_range, "f");
+        view.dispatch(view.state.tr.deleteRange(range.from, range.to).scrollIntoView());
+        action.exec(tslib_1.__classPrivateFieldGet(this, _CommandHandler_actionStorage, "f"));
+        view.focus();
+        logger_1.logger.action({ mode: 'wysiwyg', source: 'command-menu', action: action.id });
+    }
+    filterActions() {
+        var _a;
+        const currentItem = (_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f")) === null || _a === void 0 ? void 0 : _a.currentItem;
+        const inputText = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filterText, "f");
+        const enabledActions = tslib_1.__classPrivateFieldGet(this, _CommandHandler_actions, "f").filter((action) => action.isEnable(tslib_1.__classPrivateFieldGet(this, _CommandHandler_actionStorage, "f")));
+        let filteredActions = enabledActions;
+        let needToClose = false;
+        if (inputText) {
+            filteredActions = filterActions(enabledActions, inputText);
+            needToClose = !filteredActions.length && needToHide(enabledActions, inputText);
+        }
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_filteredActionsCarousel, new carousel_1.ArrayCarousel(filteredActions), "f");
+        if (currentItem) {
+            const newIndex = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f").array.findIndex((item) => item === currentItem);
+            if (newIndex !== -1) {
+                tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f").currentIndex = newIndex;
+            }
+        }
+        return needToClose;
+    }
+    render() {
+        var _a, _b, _c, _d, _e, _f;
+        this.findAnchor();
+        const viewItems = (_b = (_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f")) === null || _a === void 0 ? void 0 : _a.array) !== null && _b !== void 0 ? _b : [];
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_menuProps, {
+            anchor: tslib_1.__classPrivateFieldGet(this, _CommandHandler_anchor, "f"),
+            currentIndex: (_c = tslib_1.__classPrivateFieldGet(this, _CommandHandler_filteredActionsCarousel, "f")) === null || _c === void 0 ? void 0 : _c.currentIndex,
+            items: viewItems,
+            onClick: this.onItemClick,
+            onEscapeKeyDown: (_d = tslib_1.__classPrivateFieldGet(this, _CommandHandler_popupCloser, "f")) === null || _d === void 0 ? void 0 : _d.popupEscapeKeyHandler,
+            onOutsideClick: (_e = tslib_1.__classPrivateFieldGet(this, _CommandHandler_popupCloser, "f")) === null || _e === void 0 ? void 0 : _e.popupOutsideClickHandler,
+        }, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_menuRenderItem, (_f = tslib_1.__classPrivateFieldGet(this, _CommandHandler_menuRenderItem, "f")) !== null && _f !== void 0 ? _f : this.createMenuRenderItem(), "f");
+        tslib_1.__classPrivateFieldGet(this, _CommandHandler_menuRenderItem, "f").rerender();
+    }
+    updateState({ view, range }) {
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_view, view, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_range, range, "f");
+    }
+    clear() {
+        var _a, _b;
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_view, undefined, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_range, undefined, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_anchor, undefined, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_filterText, undefined, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_filteredActionsCarousel, undefined, "f");
+        (_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_popupCloser, "f")) === null || _a === void 0 ? void 0 : _a.cancelTimer();
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_popupCloser, undefined, "f");
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_menuProps, undefined, "f");
+        (_b = tslib_1.__classPrivateFieldGet(this, _CommandHandler_menuRenderItem, "f")) === null || _b === void 0 ? void 0 : _b.remove();
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_menuRenderItem, undefined, "f");
+    }
+    createMenuRenderItem() {
+        return (0, ReactRenderer_1.getReactRendererFromState)(tslib_1.__classPrivateFieldGet(this, _CommandHandler_view, "f").state).createItem('command_menu', () => tslib_1.__classPrivateFieldGet(this, _CommandHandler_menuProps, "f") ? (0, component_1.render)(tslib_1.__classPrivateFieldGet(this, _CommandHandler_menuProps, "f")) : null);
+    }
+    findAnchor() {
+        var _a;
+        tslib_1.__classPrivateFieldSet(this, _CommandHandler_anchor, (0, utils_1.findDecoElem)((_a = tslib_1.__classPrivateFieldGet(this, _CommandHandler_view, "f")) === null || _a === void 0 ? void 0 : _a.dom), "f");
+    }
+}
+exports.CommandHandler = CommandHandler;
+_CommandHandler_actions = new WeakMap(), _CommandHandler_actionStorage = new WeakMap(), _CommandHandler_nodesIgnoreList = new WeakMap(), _CommandHandler_filteredActionsCarousel = new WeakMap(), _CommandHandler_view = new WeakMap(), _CommandHandler_anchor = new WeakMap(), _CommandHandler_range = new WeakMap(), _CommandHandler_filterText = new WeakMap(), _CommandHandler_popupCloser = new WeakMap(), _CommandHandler_menuProps = new WeakMap(), _CommandHandler_menuRenderItem = new WeakMap();
+function filterActions(actions, text) {
+    return actions.filter((action) => action.id.toLowerCase().includes(text) ||
+        ((0, lodash_1.isFunction)(action.title) ? action.title() : action.title).toLowerCase().includes(text));
+}
+const CHARS_TO_HIDE = 4;
+function needToHide(actions, text) {
+    let iter = 1;
+    do {
+        const prevInput = text.slice(0, text.length - iter);
+        const prevActions = filterActions(actions, prevInput);
+        if (prevActions.length)
+            break;
+        iter++;
+    } while (iter < text.length && iter < CHARS_TO_HIDE);
+    return iter >= CHARS_TO_HIDE;
+}

package/build/cjs/extensions/behavior/CommandMenu/index.d.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAuto } from '../../../core';
+import type { Config } from './types';
+export declare type CommandMenuOptions = {
+    actions: Config;
+    nodesIgnoreList?: readonly string[];
+};
+export declare const CommandMenu: ExtensionAuto<CommandMenuOptions>;

package/build/cjs/extensions/behavior/CommandMenu/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandMenu = void 0;
+const markdown_1 = require("../../../extensions/markdown");
+const yfm_1 = require("../../../extensions/yfm");
+const logger_1 = require("../../../logger");
+const Autocomplete_1 = require("../Autocomplete");
+const const_1 = require("./const");
+const handler_1 = require("./handler");
+const getCommandMenuAutocompleteItem = (opts) => ({ actions }) => {
+    var _a;
+    return ({
+        trigger: {
+            name: 'command',
+            trigger: /(?:^|\s)(\/)$/,
+            allArrowKeys: false,
+            cancelOnFirstSpace: true,
+            decorationAttrs: { class: const_1.DecoClassName },
+        },
+        handler: new handler_1.CommandHandler({
+            storage: actions,
+            actions: opts.actions,
+            // TODO: add commandMenu=false flag to specs:
+            nodesIgnoreList: ((_a = opts.nodesIgnoreList) !== null && _a !== void 0 ? _a : []).concat([
+                markdown_1.DeflistNode.Term,
+                markdown_1.TableNode.HeaderCell,
+                markdown_1.TableNode.DataCell,
+                yfm_1.CheckboxNode.Label,
+                yfm_1.YfmNoteNode.NoteTitle,
+                yfm_1.CutNode.CutTitle,
+                yfm_1.TabsNode.Tab,
+            ]),
+        }),
+    });
+};
+const CommandMenu = (builder, opts) => {
+    if (!Array.isArray(opts.actions) || opts.actions.length === 0) {
+        logger_1.logger.info("[CommandMenu extension]: Skip because 'actions' is not an array or is empty");
+        return;
+    }
+    if (!builder.context.has('autocomplete')) {
+        builder.use(Autocomplete_1.Autocomplete);
+    }
+    builder.context.get('autocomplete').add(getCommandMenuAutocompleteItem(opts));
+};
+exports.CommandMenu = CommandMenu;

package/build/cjs/extensions/behavior/CommandMenu/types.d.ts

@@ -0,0 +1,4 @@
+import type { ActionStorage } from '../../../core';
+import type { ToolbarItemData } from '../../../toolbar';
+export declare type CommandAction = ToolbarItemData<ActionStorage>;
+export declare type Config = CommandAction[];

package/build/cjs/extensions/behavior/CommandMenu/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/extensions/behavior/CommandMenu/utils.d.ts

@@ -0,0 +1 @@
+export declare function findDecoElem(targetElem?: Element): Element | null;

package/build/cjs/extensions/behavior/CommandMenu/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDecoElem = void 0;
+const Autocomplete_1 = require("../Autocomplete");
+const const_1 = require("./const");
+function findDecoElem(targetElem) {
+    var _a;
+    const target = targetElem !== null && targetElem !== void 0 ? targetElem : document;
+    return ((_a = target.getElementsByClassName(const_1.DecoClassName).item(0)) !== null && _a !== void 0 ? _a : target.getElementsByClassName(Autocomplete_1.AutocompleteDecoClassName).item(0));
+}
+exports.findDecoElem = findDecoElem;

package/build/cjs/extensions/behavior/Cursor/GapCursorSelection.d.ts

@@ -0,0 +1,16 @@
+import type { Node, ResolvedPos } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import type { Mapping } from 'prosemirror-transform';
+export declare function isGapCursorSelection<T>(selection: Selection): selection is GapCursorSelection<T>;
+export declare class GapCursorSelection<T = any> extends Selection {
+    #private;
+    readonly meta?: T;
+    readonly selectionName = "GapCursorSelection";
+    get $pos(): ResolvedPos;
+    get pos(): number;
+    constructor($pos: ResolvedPos, params?: {
+        meta?: T;
+    });
+    eq(other: Selection): boolean;
+    map(doc: Node, mapping: Mapping): Selection;
+}

package/build/cjs/extensions/behavior/Cursor/GapCursorSelection.js

@@ -0,0 +1,37 @@
+"use strict";
+var _GapCursorSelection__$pos;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapCursorSelection = exports.isGapCursorSelection = void 0;
+const tslib_1 = require("tslib");
+const prosemirror_state_1 = require("prosemirror-state");
+function isGapCursorSelection(selection) {
+    return selection instanceof GapCursorSelection;
+}
+exports.isGapCursorSelection = isGapCursorSelection;
+// @ts-expect-error // TODO: implements toJSON
+class GapCursorSelection extends prosemirror_state_1.Selection {
+    constructor($pos, params) {
+        super($pos, $pos);
+        _GapCursorSelection__$pos.set(this, void 0);
+        this.selectionName = 'GapCursorSelection';
+        tslib_1.__classPrivateFieldSet(this, _GapCursorSelection__$pos, $pos, "f");
+        this.meta = params === null || params === void 0 ? void 0 : params.meta;
+    }
+    get $pos() {
+        return tslib_1.__classPrivateFieldGet(this, _GapCursorSelection__$pos, "f");
+    }
+    get pos() {
+        return tslib_1.__classPrivateFieldGet(this, _GapCursorSelection__$pos, "f").pos;
+    }
+    eq(other) {
+        return (isGapCursorSelection(other) &&
+            this.pos === other.pos &&
+            this.$pos.doc.eq(other.$pos.doc));
+    }
+    map(doc, mapping) {
+        const $pos = doc.resolve(mapping.map(this.head));
+        return prosemirror_state_1.Selection.near($pos);
+    }
+}
+exports.GapCursorSelection = GapCursorSelection;
+_GapCursorSelection__$pos = new WeakMap();

package/build/cjs/extensions/behavior/Cursor/gapcursor.css

@@ -0,0 +1,38 @@
+@charset "UTF-8";
+.Prosemirror-hide-cursor {
+  caret-color: transparent;
+}
+
+@keyframes gapcursor_blink {
+  1% {
+    border-color: unset;
+  }
+  49% {
+    border-color: unset;
+  }
+  50% {
+    border-color: transparent;
+  }
+  99% {
+    border-color: transparent;
+  }
+}
+.g-md-gapcursor {
+  cursor: text;
+}
+.g-md-gapcursor .g-md-placeholder::before {
+  display: none;
+}
+.g-md-gapcursor::before {
+  position: relative;
+  z-index: 1;
+  display: inline-block;
+  margin-right: -1px;
+  content: " ";
+  caret-color: transparent;
+  border-right: 1px solid transparent;
+}
+.ProseMirror-focused .g-md-gapcursor::before {
+  animation: gapcursor_blink 1s;
+  animation-iteration-count: infinite;
+}

package/build/cjs/extensions/behavior/Cursor/gapcursor.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare const gapCursor: () => Plugin<boolean>;

package/build/cjs/extensions/behavior/Cursor/gapcursor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gapCursor = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_view_1 = require("prosemirror-view");
+const selection_1 = require("../../../utils/selection");
+const BaseSchema_1 = require("../../base/BaseSchema");
+const Placeholder_1 = require("../../behavior/Placeholder");
+const GapCursorSelection_1 = require("./GapCursorSelection");
+const key = new prosemirror_state_1.PluginKey('gapCursorPlugin');
+const gapCursor = () => new prosemirror_state_1.Plugin({
+    key,
+    state: {
+        init: () => false,
+        apply: (_tr, _pluginState, _oldState, newState) => {
+            const sel = newState.selection;
+            return (0, GapCursorSelection_1.isGapCursorSelection)(sel) || (0, selection_1.isNodeSelection)(sel);
+        },
+    },
+    view() {
+        return {
+            update(view) {
+                const pluginState = key.getState(view.state);
+                view.dom.classList.toggle('Prosemirror-hide-cursor', pluginState);
+            },
+        };
+    },
+    props: {
+        decorations: ({ doc, selection }) => {
+            if ((0, GapCursorSelection_1.isGapCursorSelection)(selection)) {
+                const position = selection.head;
+                return prosemirror_view_1.DecorationSet.create(doc, [
+                    prosemirror_view_1.Decoration.widget(position, toDOM, {
+                        key: 'gapcursor',
+                        side: -1,
+                    }),
+                ]);
+            }
+            return null;
+        },
+    },
+});
+exports.gapCursor = gapCursor;
+const toDOM = (view, getPos) => {
+    const node = (0, BaseSchema_1.pType)(view.state.schema).create();
+    const element = prosemirror_model_1.DOMSerializer.fromSchema(view.state.schema).serializeNode(node);
+    const placeholderDOM = (0, Placeholder_1.createPlaceholder)(node, null, true);
+    if (placeholderDOM)
+        element.appendChild(placeholderDOM);
+    element.classList.add('g-md-gapcursor');
+    element.addEventListener('mousedown', () => {
+        const pos = getPos();
+        if (pos !== undefined) {
+            view.dispatch(view.state.tr.replaceSelectionWith(node));
+        }
+    });
+    return element;
+};

package/build/cjs/extensions/behavior/Cursor/index.d.ts

@@ -0,0 +1,7 @@
+import { dropCursor } from 'prosemirror-dropcursor';
+import type { ExtensionAuto } from '../../../core';
+export { GapCursorSelection, isGapCursorSelection } from './GapCursorSelection';
+export declare type CursorOptions = {
+    dropOptions?: Parameters<typeof dropCursor>[0];
+};
+export declare const Cursor: ExtensionAuto<CursorOptions>;

package/build/cjs/extensions/behavior/Cursor/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = exports.isGapCursorSelection = exports.GapCursorSelection = void 0;
+const prosemirror_dropcursor_1 = require("prosemirror-dropcursor");
+const gapcursor_1 = require("./gapcursor");
+var GapCursorSelection_1 = require("./GapCursorSelection");
+Object.defineProperty(exports, "GapCursorSelection", { enumerable: true, get: function () { return GapCursorSelection_1.GapCursorSelection; } });
+Object.defineProperty(exports, "isGapCursorSelection", { enumerable: true, get: function () { return GapCursorSelection_1.isGapCursorSelection; } });
+const Cursor = (builder, opts) => {
+    builder.addPlugin(() => (0, gapcursor_1.gapCursor)());
+    builder.addPlugin(() => (0, prosemirror_dropcursor_1.dropCursor)(opts.dropOptions));
+};
+exports.Cursor = Cursor;

package/build/cjs/extensions/behavior/EditorModeKeymap/index.d.ts

@@ -0,0 +1,12 @@
+import { ExtensionAuto } from '../../../core';
+export declare type EditorModeKeymapOptions = {
+    /** Submit handler. Return true to stop propagation. */
+    onSubmit?(): boolean;
+    /** Cancel handler. Return true to stop propagation. */
+    onCancel?(): boolean;
+    ignoreKeysList?: string[];
+};
+/**
+ * Use this extension if you need to handle form actions like cancel and/or submit.
+ */
+export declare const EditorModeKeymap: ExtensionAuto<EditorModeKeymapOptions>;

package/build/cjs/extensions/behavior/EditorModeKeymap/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorModeKeymap = void 0;
+const shortcuts_1 = require("../../../shortcuts");
+const version_1 = require("../../../version");
+/**
+ * Use this extension if you need to handle form actions like cancel and/or submit.
+ */
+const EditorModeKeymap = (builder, opts) => {
+    var _a;
+    builder.addKeymap(() => {
+        const bindings = {};
+        const { onCancel, onSubmit } = opts;
+        if (onCancel)
+            bindings[shortcuts_1.formatter.toPM(shortcuts_1.Action.Cancel)] = () => onCancel();
+        if (onSubmit)
+            bindings[shortcuts_1.formatter.toPM(shortcuts_1.Action.Submit)] = () => onSubmit();
+        bindings[shortcuts_1.formatter.toPM(shortcuts_1.Action.__debug)] = () => {
+            debug();
+            return true;
+        };
+        return bindings;
+    });
+    if ((_a = opts.ignoreKeysList) === null || _a === void 0 ? void 0 : _a.length) {
+        const ignore = () => true;
+        const bindings = {};
+        for (const key of opts.ignoreKeysList) {
+            bindings[key] = ignore;
+        }
+        builder.addKeymap(() => bindings, builder.Priority.Lowest);
+    }
+};
+exports.EditorModeKeymap = EditorModeKeymap;
+function debug() {
+    const message = ['YFM-Editor Debug info', `Version: ${version_1.VERSION}`].join('\n');
+    console.info(message);
+}

package/build/cjs/extensions/behavior/FilePaste/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAuto } from '../../../core';
+export declare const FilePaste: ExtensionAuto;

package/build/cjs/extensions/behavior/FilePaste/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePaste = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_transform_1 = require("prosemirror-transform");
+const base_1 = require("../../../extensions/base");
+const utils_1 = require("../Clipboard/utils");
+// Custom handler of pasted (or dropped) files to prevent insert a file preview in base64-format into editor's content (or open file in browser)
+const FilePaste = (builder) => {
+    builder.addPlugin(() => {
+        return new prosemirror_state_1.Plugin({
+            props: {
+                handlePaste(view, event) {
+                    const files = getFiles(event.clipboardData);
+                    if (!files)
+                        return false;
+                    view.dispatch(view.state.tr
+                        .replaceSelection(createFilesSlice(view.state.schema, files))
+                        .scrollIntoView());
+                    return true;
+                },
+                handleDrop(view, event) {
+                    var _a, _b;
+                    if (view.dragging)
+                        return false;
+                    const files = getFiles(event.dataTransfer);
+                    if (!files)
+                        return false;
+                    const slice = createFilesSlice(view.state.schema, files);
+                    const dropPos = (_b = (_a = view.posAtCoords({ left: event.clientX, top: event.clientY })) === null || _a === void 0 ? void 0 : _a.pos) !== null && _b !== void 0 ? _b : -1;
+                    if (dropPos === -1)
+                        return false;
+                    const posToInsert = (0, prosemirror_transform_1.dropPoint)(view.state.doc, dropPos, slice);
+                    if (posToInsert === null)
+                        return false;
+                    view.dispatch(view.state.tr.insert(posToInsert, slice.content));
+                    return true;
+                },
+            },
+        });
+    }, builder.Priority.Lowest);
+};
+exports.FilePaste = FilePaste;
+function getFiles(dataTransfer) {
+    if (!dataTransfer || !(0, utils_1.isFilesOnly)(dataTransfer))
+        return null;
+    return Array.from(dataTransfer.files);
+}
+function createFilesSlice(schema, files) {
+    const nodes = [];
+    for (const file of files) {
+        nodes.push((0, base_1.pType)(schema).create(null, schema.text(file.name)));
+    }
+    return new prosemirror_model_1.Slice(prosemirror_model_1.Fragment.from(nodes), 0, 0);
+}

package/build/cjs/extensions/behavior/History/index.d.ts

@@ -0,0 +1,21 @@
+import { history } from 'prosemirror-history';
+import type { Action, ExtensionAuto } from '../../../core';
+declare enum HistoryAction {
+    Undo = "undo",
+    Redo = "redo"
+}
+export declare type HistoryOptions = {
+    config?: Parameters<typeof history>[0];
+    undoKey?: string | null;
+    redoKey?: string | null;
+};
+export declare const History: ExtensionAuto<HistoryOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [HistoryAction.Undo]: Action;
+            [HistoryAction.Redo]: Action;
+        }
+    }
+}
+export {};