@gravity-ui/markdown-editor 13.0.0

package/build/cjs/core/types/extension.d.ts

@@ -0,0 +1,44 @@
+import type MarkdownIt from 'markdown-it';
+import type OrderedMap from 'orderedmap';
+import type { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import type { Plugin } from 'prosemirror-state';
+import type { ExtensionBuilder } from '../ExtensionBuilder';
+import type { ActionSpec, ActionStorage } from './actions';
+import type { MarkViewConstructor, NodeViewConstructor } from './node-views';
+import type { Parser, ParserToken } from './parser';
+import type { Serializer, SerializerMarkToken, SerializerNodeToken } from './serializer';
+export declare type Extension = (builder: ExtensionBuilder) => void;
+export declare type ExtensionWithOptions<T> = (builder: ExtensionBuilder, options: T) => void;
+export declare type ExtensionAuto<T = void> = T extends void ? Extension : ExtensionWithOptions<T>;
+export declare type ExtensionSpec = {
+    configureMd(md: MarkdownIt, parserType: 'text' | 'markup'): MarkdownIt;
+    nodes(): OrderedMap<ExtensionNodeSpec>;
+    marks(): OrderedMap<ExtensionMarkSpec>;
+    plugins(deps: ExtensionDeps): Plugin[];
+    actions(deps: ExtensionDeps): Record<string, ActionSpec>;
+};
+export declare type ExtensionNodeSpec = {
+    spec: NodeSpec;
+    view?: (deps: ExtensionDeps) => NodeViewConstructor;
+    fromMd: {
+        tokenName?: string;
+        tokenSpec: ParserToken;
+    };
+    toMd: SerializerNodeToken;
+};
+export declare type ExtensionMarkSpec = {
+    spec: MarkSpec;
+    view?: (deps: ExtensionDeps) => MarkViewConstructor;
+    fromMd: {
+        tokenName?: string;
+        tokenSpec: ParserToken;
+    };
+    toMd: SerializerMarkToken;
+};
+export declare type ExtensionDeps = {
+    readonly schema: Schema;
+    readonly textParser: Parser;
+    readonly markupParser: Parser;
+    readonly serializer: Serializer;
+    readonly actions: ActionStorage;
+};

package/build/cjs/core/types/extension.js

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

package/build/cjs/core/types/keymap.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'prosemirror-state';
+export declare type Keymap = {
+    [key: string]: Command;
+};

package/build/cjs/core/types/keymap.js

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

package/build/cjs/core/types/node-views.d.ts

@@ -0,0 +1,2 @@
+import type { MarkViewConstructor, NodeViewConstructor } from 'prosemirror-view';
+export type { NodeViewConstructor, MarkViewConstructor };

package/build/cjs/core/types/node-views.js

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

package/build/cjs/core/types/parser.d.ts

@@ -0,0 +1,29 @@
+import type { Match } from 'linkify-it';
+import type Token from 'markdown-it/lib/token';
+import type { Node } from 'prosemirror-model';
+export interface Parser {
+    /** Parse raw markup to prosemirror's root node */
+    parse(markup: string): Node;
+    validateLink(url: string): boolean;
+    normalizeLink(url: string): string;
+    normalizeLinkText(url: string): string;
+    matchLinks(text: string): Readonly<Match>[] | null;
+}
+export interface ParserToken {
+    name: string;
+    type: 'node' | 'block' | 'mark';
+    attrs?: {
+        [name: string]: unknown;
+    };
+    getAttrs?: (token: Token, tokens: Token[], index: number) => NonNullable<ParserToken['attrs']>;
+    noCloseToken?: boolean;
+    ignore?: boolean;
+    code?: boolean;
+    /** only for tokens with type=block */
+    prepareContent?: (content: string) => string;
+    /**
+     * only for tokens with type=block and noCloseToken=true
+     * @default 'content'
+     */
+    contentField?: 'content' | 'children';
+}

package/build/cjs/core/types/parser.js

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

package/build/cjs/core/types/serializer.d.ts

@@ -0,0 +1,29 @@
+import type { Fragment, Mark, Node } from 'prosemirror-model';
+import type { MarkdownSerializerState as SerializerState } from '../markdown/MarkdownSerializer';
+export type { MarkdownSerializerState as SerializerState } from '../markdown/MarkdownSerializer';
+export interface Serializer {
+    /** Serialize the content of the given node to markup */
+    serialize(content: Node | Fragment, options?: object): string;
+}
+export interface SerializerTests extends Serializer {
+    containsNode(nodeName: string): boolean;
+    containsMark(markName: string): boolean;
+}
+/** see MarkdownSerializer */
+export interface SerializerNodeToken {
+    (state: SerializerState, node: Node, parent: Node, index: number): void;
+}
+/** see MarkdownSerializer */
+export interface SerializerMarkToken {
+    open: string | ((state: SerializerState, node: Mark, parent: Fragment, index: number) => string);
+    close: string | ((state: SerializerState, node: Mark, parent: Fragment, index: number) => string);
+    mixable?: boolean;
+    escape?: boolean;
+    expelEnclosingWhitespace?: boolean;
+}
+declare module 'prosemirror-model' {
+    interface NodeSpec {
+        /** Default false */
+        isBreak?: boolean;
+    }
+}

package/build/cjs/core/types/serializer.js

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

package/build/cjs/core/utils/actions.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+import type { Action, ActionSpec } from '../types/actions';
+export declare function bindActions<Keys extends string = string>(rawActions: Record<Keys, ActionSpec>): (view: EditorView) => Record<Keys, Action<Record<string, unknown>>>;

package/build/cjs/core/utils/actions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindActions = void 0;
+function bindActions(rawActions) {
+    return function (view) {
+        return Object.entries(rawActions).reduce((acc, [key, spec]) => {
+            acc[key] = {
+                isActive: () => { var _a, _b; return (_b = (_a = spec.isActive) === null || _a === void 0 ? void 0 : _a.call(spec, view.state)) !== null && _b !== void 0 ? _b : false; },
+                isEnable: (arg) => spec.isEnable(view.state, undefined, view, arg),
+                run: (arg) => spec.run(view.state, view.dispatch, view, arg),
+                meta: () => { var _a; return (_a = spec.meta) === null || _a === void 0 ? void 0 : _a.call(spec, view.state); },
+            };
+            return acc;
+        }, {});
+    };
+}
+exports.bindActions = bindActions;

package/build/cjs/core/utils/metrics.d.ts

@@ -0,0 +1,3 @@
+import type { Transaction } from 'prosemirror-state';
+export declare const trackTransactionMetrics: (tr: Transaction, type: string, meta?: Record<string, any>) => Transaction;
+export declare const logTransactionMetrics: (tr: Transaction) => void;

package/build/cjs/core/utils/metrics.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTransactionMetrics = exports.trackTransactionMetrics = void 0;
+const logger_1 = require("../../logger");
+const METRICS_KEY = 'metrics';
+const trackTransactionMetrics = (tr, type, meta) => {
+    tr.setMeta(METRICS_KEY, { type, meta });
+    return tr;
+};
+exports.trackTransactionMetrics = trackTransactionMetrics;
+const logTransactionMetrics = (tr) => {
+    const metrics = tr.getMeta(METRICS_KEY);
+    if (metrics) {
+        logger_1.logger.metrics({
+            component: 'transaction',
+            event: metrics.type,
+            duration: Date.now() - tr.time,
+            meta: metrics.meta,
+        });
+    }
+};
+exports.logTransactionMetrics = logTransactionMetrics;

package/build/cjs/extensions/base/BaseInputRules/index.d.ts

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

package/build/cjs/extensions/base/BaseInputRules/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseInputRules = void 0;
+const prosemirror_inputrules_1 = require("prosemirror-inputrules");
+const BaseInputRules = (builder) => {
+    builder.addInputRules(() => ({ rules: [...prosemirror_inputrules_1.smartQuotes, prosemirror_inputrules_1.ellipsis] }));
+};
+exports.BaseInputRules = BaseInputRules;

package/build/cjs/extensions/base/BaseKeymap/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAuto } from '../../../core';
+/**
+ * Add this extension after all other extensions with keymaps
+ */
+export declare const BaseKeymap: ExtensionAuto;

package/build/cjs/extensions/base/BaseKeymap/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseKeymap = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_inputrules_1 = require("prosemirror-inputrules");
+/**
+ * Add this extension after all other extensions with keymaps
+ */
+const BaseKeymap = (builder) => {
+    builder
+        .addKeymap(() => ({
+        Backspace: prosemirror_inputrules_1.undoInputRule,
+        'Mod-BracketLeft': prosemirror_commands_1.lift,
+        'Alt-Shift-Escape': prosemirror_commands_1.selectParentNode,
+    }), builder.PluginPriority.Lowest)
+        .addKeymap(() => prosemirror_commands_1.baseKeymap, builder.PluginPriority.Lowest);
+};
+exports.BaseKeymap = BaseKeymap;

package/build/cjs/extensions/base/BaseSchema/BaseSchemaSpecs/index.d.ts

@@ -0,0 +1,12 @@
+import type { NodeSpec } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export declare enum BaseNode {
+    Doc = "doc",
+    Text = "text",
+    Paragraph = "paragraph"
+}
+export declare const pType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type BaseSchemaSpecsOptions = {
+    paragraphPlaceholder?: NonNullable<NodeSpec['placeholder']>['content'];
+};
+export declare const BaseSchemaSpecs: ExtensionAuto<BaseSchemaSpecsOptions>;

package/build/cjs/extensions/base/BaseSchema/BaseSchemaSpecs/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSchemaSpecs = exports.pType = exports.BaseNode = void 0;
+const schema_1 = require("../../../../utils/schema");
+var BaseNode;
+(function (BaseNode) {
+    BaseNode["Doc"] = "doc";
+    BaseNode["Text"] = "text";
+    BaseNode["Paragraph"] = "paragraph";
+})(BaseNode = exports.BaseNode || (exports.BaseNode = {}));
+const paragraphLineNumberAttr = 'data-line';
+exports.pType = (0, schema_1.nodeTypeFactory)(BaseNode.Paragraph);
+const BaseSchemaSpecs = (builder, opts) => {
+    builder
+        .addNode(BaseNode.Doc, () => ({
+        spec: {
+            content: 'block+',
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Doc, type: 'block', ignore: true } },
+        toMd: () => {
+            throw new Error('Unexpected toMd() call on doc node');
+        },
+    }))
+        .addNode(BaseNode.Text, () => ({
+        spec: {
+            group: 'inline',
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Text, type: 'node', ignore: true } },
+        toMd: (state, node, parent) => {
+            const { escapeText } = parent.type.spec;
+            state.text(node.text, escapeText !== null && escapeText !== void 0 ? escapeText : !state.isAutolink);
+        },
+    }))
+        .addNode(BaseNode.Paragraph, () => ({
+        spec: {
+            attrs: { [paragraphLineNumberAttr]: { default: null } },
+            content: 'inline*',
+            group: 'block',
+            parseDOM: [{ tag: 'p' }],
+            toDOM(node) {
+                const lineNumber = node.attrs[paragraphLineNumberAttr];
+                return [
+                    'p',
+                    lineNumber === null ? {} : { [paragraphLineNumberAttr]: lineNumber },
+                    0,
+                ];
+            },
+            placeholder: opts.paragraphPlaceholder
+                ? {
+                    content: opts.paragraphPlaceholder,
+                    alwaysVisible: false,
+                }
+                : undefined,
+        },
+        fromMd: { tokenSpec: { name: BaseNode.Paragraph, type: 'block' } },
+        toMd: (state, node) => {
+            state.renderInline(node);
+            state.closeBlock(node);
+        },
+    }));
+};
+exports.BaseSchemaSpecs = BaseSchemaSpecs;

package/build/cjs/extensions/base/BaseSchema/index.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'prosemirror-state';
+import type { Action, ExtensionAuto } from '../../../core';
+import { BaseSchemaSpecsOptions } from './BaseSchemaSpecs';
+export { BaseNode, pType } from './BaseSchemaSpecs';
+declare const pAction = "toParagraph";
+export declare const toParagraph: Command;
+export declare type BaseSchemaOptions = BaseSchemaSpecsOptions & {
+    paragraphKey?: string | null;
+};
+export declare const BaseSchema: ExtensionAuto<BaseSchemaOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [pAction]: Action;
+        }
+    }
+}

package/build/cjs/extensions/base/BaseSchema/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSchema = exports.toParagraph = exports.pType = exports.BaseNode = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const keymap_1 = require("../../../utils/keymap");
+const BaseSchemaSpecs_1 = require("./BaseSchemaSpecs");
+var BaseSchemaSpecs_2 = require("./BaseSchemaSpecs");
+Object.defineProperty(exports, "BaseNode", { enumerable: true, get: function () { return BaseSchemaSpecs_2.BaseNode; } });
+Object.defineProperty(exports, "pType", { enumerable: true, get: function () { return BaseSchemaSpecs_2.pType; } });
+const pAction = 'toParagraph';
+const toParagraph = (state, dispatch) => (0, prosemirror_commands_1.setBlockType)((0, BaseSchemaSpecs_1.pType)(state.schema))(state, dispatch);
+exports.toParagraph = toParagraph;
+const BaseSchema = (builder, opts) => {
+    builder.use(BaseSchemaSpecs_1.BaseSchemaSpecs, opts);
+    const { paragraphKey } = opts;
+    if (paragraphKey) {
+        builder.addKeymap(({ schema }) => ({
+            [paragraphKey]: (0, keymap_1.withLogAction)('paragraph', (0, prosemirror_commands_1.setBlockType)((0, BaseSchemaSpecs_1.pType)(schema))),
+        }));
+    }
+    builder.addAction(pAction, ({ schema }) => {
+        const p = (0, BaseSchemaSpecs_1.pType)(schema);
+        const cmd = (0, prosemirror_commands_1.setBlockType)(p);
+        const isParagraph = (state) => (0, prosemirror_utils_1.hasParentNodeOfType)(p)(state.selection);
+        return {
+            isActive: isParagraph,
+            isEnable: (0, prosemirror_commands_1.chainCommands)(isParagraph, cmd),
+            run: cmd,
+        };
+    });
+};
+exports.BaseSchema = BaseSchema;

package/build/cjs/extensions/base/BaseStyles/index.css

@@ -0,0 +1,84 @@
+.ProseMirror {
+  position: relative;
+}
+
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
+}
+
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+
+.ProseMirror li {
+  position: relative;
+}
+
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection {
+  caret-color: transparent;
+}
+
+/* See https://github.com/ProseMirror/prosemirror/issues/1421#issuecomment-1759320191 */
+.ProseMirror [draggable][contenteditable=false] {
+  user-select: text;
+}
+
+.ProseMirror-selectednode {
+  outline: 2px solid #8cf;
+}
+
+/* Make sure li selections wrap around markers */
+li.ProseMirror-selectednode {
+  outline: none;
+}
+
+li.ProseMirror-selectednode:after {
+  content: "";
+  position: absolute;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
+  border: 2px solid #8cf;
+  pointer-events: none;
+}
+
+/* Protect against generic img rules */
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+}
+
+.ProseMirror-selectednode {
+  outline: none;
+}
+
+.li.ProseMirror-selectednode:after {
+  border: none;
+}
+
+.g-md-editor.ProseMirror-focused .ProseMirror-selectednode {
+  outline: 2px solid #8cf;
+}
+.g-md-editor.ProseMirror-focused li.ProseMirror-selectednode:after {
+  border: 2px solid #8cf;
+}
+
+.g-md-editor.ProseMirror:focus,
+.g-md-editor .ProseMirror:focus {
+  outline: none;
+}

package/build/cjs/extensions/base/BaseStyles/index.d.ts

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

package/build/cjs/extensions/base/BaseStyles/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStyles = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const BaseStyles = (builder) => {
+    builder.addPlugin(() => new prosemirror_state_1.Plugin({
+        props: {
+            attributes: {
+                class: 'g-md-editor',
+            },
+        },
+    }));
+};
+exports.BaseStyles = BaseStyles;

package/build/cjs/extensions/base/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BaseSchema';
+export * from './BaseStyles';
+export * from './BaseKeymap';
+export * from './BaseInputRules';

package/build/cjs/extensions/base/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./BaseSchema"), exports);
+tslib_1.__exportStar(require("./BaseStyles"), exports);
+tslib_1.__exportStar(require("./BaseKeymap"), exports);
+tslib_1.__exportStar(require("./BaseInputRules"), exports);

package/build/cjs/extensions/base/specs.d.ts

@@ -0,0 +1 @@
+export * from './BaseSchema/BaseSchemaSpecs';

package/build/cjs/extensions/base/specs.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./BaseSchema/BaseSchemaSpecs"), exports);

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

@@ -0,0 +1,14 @@
+import type { AutocompleteAction, AutocompleteHandler, AutocompleteItem } from './types';
+export declare type MainHandlerConfig = readonly AutocompleteItem[];
+export declare class MainHandler implements Required<AutocompleteHandler> {
+    private static log;
+    private readonly config;
+    constructor(config: MainHandlerConfig);
+    onOpen(action: AutocompleteAction): boolean;
+    onClose(action: AutocompleteAction): boolean;
+    onArrow(action: AutocompleteAction): boolean;
+    onEnter(action: AutocompleteAction): boolean;
+    onFilter(action: AutocompleteAction): boolean;
+    onDestroy(): void;
+    private getItem;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainHandler = void 0;
+const lodash_1 = require("../../../lodash");
+const logger_1 = require("../../../logger");
+class MainHandler {
+    constructor(config) {
+        this.config = config;
+    }
+    static log(opts) {
+        const prefix = '[Autocomplete]';
+        if (opts.event === 'destroy') {
+            logger_1.logger.log(`${prefix} Destroy`);
+            return;
+        }
+        const { action, item } = opts;
+        const msg = [
+            prefix,
+            (0, lodash_1.capitalize)(opts.event),
+            `Trigger="${action.trigger}"`,
+            `Filter=${action.filter !== undefined ? `"${action.filter}"` : 'None'}`,
+            `Type=${action.type ? `"${action.type.name}"` : 'None'}`,
+            `Handler=${item ? `"${item.trigger.name}"` : 'None'}`,
+        ].join(' ');
+        logger_1.logger.log(msg);
+    }
+    onOpen(action) {
+        var _a, _b, _c;
+        const item = this.getItem(action);
+        MainHandler.log({ event: 'open', action, item });
+        return (_c = (_b = item === null || item === void 0 ? void 0 : (_a = item.handler).onOpen) === null || _b === void 0 ? void 0 : _b.call(_a, action)) !== null && _c !== void 0 ? _c : false;
+    }
+    onClose(action) {
+        var _a, _b, _c;
+        const item = this.getItem(action);
+        MainHandler.log({ event: 'close', action, item });
+        return (_c = (_b = item === null || item === void 0 ? void 0 : (_a = item.handler).onClose) === null || _b === void 0 ? void 0 : _b.call(_a, action)) !== null && _c !== void 0 ? _c : false;
+    }
+    onArrow(action) {
+        var _a, _b, _c;
+        const item = this.getItem(action);
+        MainHandler.log({ event: 'arrow', action, item });
+        return (_c = (_b = item === null || item === void 0 ? void 0 : (_a = item.handler).onArrow) === null || _b === void 0 ? void 0 : _b.call(_a, action)) !== null && _c !== void 0 ? _c : false;
+    }
+    onEnter(action) {
+        var _a, _b, _c;
+        const item = this.getItem(action);
+        MainHandler.log({ event: 'enter', action, item });
+        return (_c = (_b = item === null || item === void 0 ? void 0 : (_a = item.handler).onEnter) === null || _b === void 0 ? void 0 : _b.call(_a, action)) !== null && _c !== void 0 ? _c : false;
+    }
+    onFilter(action) {
+        var _a, _b, _c;
+        const item = this.getItem(action);
+        MainHandler.log({ event: 'filter', action, item });
+        return (_c = (_b = item === null || item === void 0 ? void 0 : (_a = item.handler).onFilter) === null || _b === void 0 ? void 0 : _b.call(_a, action)) !== null && _c !== void 0 ? _c : false;
+    }
+    onDestroy() {
+        var _a, _b;
+        MainHandler.log({ event: 'destroy' });
+        for (const item of this.config) {
+            (_b = (_a = item.handler).onDestroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+    }
+    getItem({ trigger, type }) {
+        let predicate;
+        if (type) {
+            predicate = (item) => item.trigger.name === type.name;
+        }
+        else {
+            predicate = (item) => {
+                const itemTrigger = item.trigger.trigger;
+                if ((0, lodash_1.isString)(itemTrigger))
+                    return itemTrigger === trigger;
+                return itemTrigger.test(trigger);
+            };
+        }
+        return this.config.find(predicate);
+    }
+}
+exports.MainHandler = MainHandler;

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

@@ -0,0 +1,24 @@
+import { ExtensionAuto, ExtensionDeps } from '../../../core';
+import type { AutocompleteItem } from './types';
+export { openAutocomplete, closeAutocomplete } from 'prosemirror-autocomplete';
+export declare const AutocompleteDecoClassName = "autocomplete";
+export declare type AutocompleteItemFn = (deps: ExtensionDeps) => AutocompleteItem;
+export * from './types';
+declare type Storage = {
+    add(item: AutocompleteItem | AutocompleteItemFn): Storage;
+};
+/**
+ * This extension is wrapper of _prosemirror-autocomplete_
+ * You only need to use it once.
+ * Don't add this extension many times with different options.
+ * Don't import anything from the _prosemirror-autocomplete_ source package.
+ * Everything you need is exported from this module.
+ */
+export declare const Autocomplete: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Context {
+            autocomplete: Storage;
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autocomplete = exports.AutocompleteDecoClassName = exports.closeAutocomplete = exports.openAutocomplete = void 0;
+const tslib_1 = require("tslib");
+const prosemirror_autocomplete_1 = tslib_1.__importDefault(require("prosemirror-autocomplete"));
+const prosemirror_state_1 = require("prosemirror-state");
+const lodash_1 = require("../../../lodash");
+const handler_1 = require("./handler");
+var prosemirror_autocomplete_2 = require("prosemirror-autocomplete");
+Object.defineProperty(exports, "openAutocomplete", { enumerable: true, get: function () { return prosemirror_autocomplete_2.openAutocomplete; } });
+Object.defineProperty(exports, "closeAutocomplete", { enumerable: true, get: function () { return prosemirror_autocomplete_2.closeAutocomplete; } });
+exports.AutocompleteDecoClassName = 'autocomplete';
+tslib_1.__exportStar(require("./types"), exports);
+/**
+ * This extension is wrapper of _prosemirror-autocomplete_
+ * You only need to use it once.
+ * Don't add this extension many times with different options.
+ * Don't import anything from the _prosemirror-autocomplete_ source package.
+ * Everything you need is exported from this module.
+ */
+const Autocomplete = (builder) => {
+    const storage = new Set();
+    builder.context.set('autocomplete', storage);
+    builder.addPlugin((deps) => {
+        const triggers = [];
+        const config = [];
+        for (const itemOrFn of storage) {
+            const item = (0, lodash_1.isFunction)(itemOrFn) ? itemOrFn(deps) : itemOrFn;
+            triggers.push(item.trigger);
+            config.push(item);
+        }
+        const handler = new handler_1.MainHandler(config);
+        const plugins = (0, prosemirror_autocomplete_1.default)({
+            triggers,
+            onOpen: handler.onOpen.bind(handler),
+            onClose: handler.onClose.bind(handler),
+            onFilter: handler.onFilter.bind(handler),
+            onArrow: handler.onArrow.bind(handler),
+            onEnter: handler.onEnter.bind(handler),
+        });
+        /**
+         * BugFix: because _prosemirror-autocomplete_ does not handle the destruction of the view,
+         * we have to handle it ourselves
+         */
+        return plugins.concat(new prosemirror_state_1.Plugin({
+            view: () => ({
+                destroy: () => handler.onDestroy(),
+            }),
+        }));
+    }, builder.Priority.VeryHigh);
+};
+exports.Autocomplete = Autocomplete;