@gravity-ui/markdown-editor 13.0.0

package/build/esm/commands/join.js

@@ -0,0 +1,58 @@
+import { NodeSelection, TextSelection } from 'prosemirror-state';
+import { getLastChildOfNode } from '../utils/nodes';
+import { get$CursorAtBlockStart } from '../utils/selection';
+export const joinPreviousBlock = ({ checkPrevNode, skipNode }) => (state, dispatch) => {
+    const $cursor = get$CursorAtBlockStart(state.selection);
+    if (!$cursor)
+        return false;
+    const index = $cursor.index(-1);
+    const nodeBefore = $cursor.node(-1).maybeChild(index - 1);
+    if (!nodeBefore || !checkPrevNode(nodeBefore))
+        return false;
+    const textBlock = $cursor.parent;
+    const docWithTextBlock = state.schema.topNodeType.create(null, textBlock);
+    const isEmptyTextblock = textBlock.childCount === 0;
+    let node = nodeBefore;
+    let offset = $cursor.before() - nodeBefore.nodeSize;
+    let lastChild;
+    while ((lastChild = getLastChildOfNode(node))) {
+        if (lastChild.node.isTextblock) {
+            const tr = state.tr;
+            const insertPos = offset + lastChild.offset + lastChild.node.nodeSize;
+            tr.delete($cursor.before(), $cursor.after());
+            tr.insert(insertPos, textBlock.content);
+            tr.setSelection(TextSelection.create(tr.doc, insertPos));
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr.scrollIntoView());
+            return true;
+        }
+        if (!skipNode(lastChild.node) && lastChild.node.canAppend(docWithTextBlock)) {
+            const tr = state.tr;
+            const insertPos = offset + 1 + lastChild.offset + lastChild.node.nodeSize - 1;
+            tr.delete($cursor.before(), $cursor.after());
+            tr.insert(insertPos, textBlock);
+            tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr.scrollIntoView());
+            return true;
+        }
+        if (lastChild.node.isAtom || lastChild.node.isLeaf) {
+            const { tr } = state;
+            if (isEmptyTextblock) {
+                tr.delete($cursor.before(), $cursor.after());
+                tr.setSelection(NodeSelection.create(tr.doc, offset + 1 + lastChild.offset));
+            }
+            else if (!skipNode(node) && node.canAppend(docWithTextBlock)) {
+                const insertPos = offset + node.nodeSize - 1;
+                tr.insert(insertPos, textBlock);
+                tr.setSelection(TextSelection.create(tr.doc, insertPos));
+            }
+            else {
+                tr.setSelection(NodeSelection.create(tr.doc, offset + 1 + lastChild.offset));
+            }
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr.scrollIntoView());
+            return true;
+        }
+        node = lastChild.node;
+        offset += lastChild.offset + 1;
+    }
+    return false;
+};

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

@@ -0,0 +1,14 @@
+export declare type MarkupString = string & {};
+export interface CommonEditor extends ContentHandler {
+    focus(): void;
+    hasFocus(): boolean;
+    getValue(): MarkupString;
+    isEmpty(): boolean;
+}
+export interface ContentHandler {
+    clear(): void;
+    replace(newMarkup: MarkupString): void;
+    prepend(markup: MarkupString): void;
+    append(markup: MarkupString): void;
+    moveCursor(position: 'start' | 'end'): void;
+}

package/build/esm/common/index.js

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

package/build/esm/configure.d.ts

@@ -0,0 +1,12 @@
+export declare enum Lang {
+    Ru = "ru",
+    En = "en"
+}
+interface Config {
+    lang?: `${Lang}`;
+}
+declare type Subscriber = (config: Readonly<Config>) => void;
+export declare const configure: (newConfig: Config) => void;
+export declare const subscribeConfigure: (sub: Subscriber) => () => void;
+export declare const getConfig: () => Readonly<Config>;
+export {};

package/build/esm/configure.js

@@ -0,0 +1,20 @@
+export var Lang;
+(function (Lang) {
+    Lang["Ru"] = "ru";
+    Lang["En"] = "en";
+})(Lang || (Lang = {}));
+let subs = [];
+const config = {};
+export const configure = (newConfig) => {
+    Object.assign(config, newConfig);
+    subs.forEach((sub) => {
+        sub(config);
+    });
+};
+export const subscribeConfigure = (sub) => {
+    subs.push(sub);
+    return () => {
+        subs = subs.filter((item) => item !== sub);
+    };
+};
+export const getConfig = () => config;

package/build/esm/core/ActionsManager.d.ts

@@ -0,0 +1,8 @@
+import type { ActionStorage } from './types/actions';
+export declare class ActionsManager implements ActionStorage {
+    #private;
+    get actions(): WysiwygEditor.Actions;
+    constructor(actions?: WysiwygEditor.Actions);
+    action<T extends keyof WysiwygEditor.Actions>(actionName: T): WysiwygEditor.Actions[T];
+    setActions(actions: WysiwygEditor.Actions): this;
+}

package/build/esm/core/ActionsManager.js

@@ -0,0 +1,19 @@
+var _ActionsManager_actions;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+export class ActionsManager {
+    constructor(actions) {
+        _ActionsManager_actions.set(this, void 0);
+        __classPrivateFieldSet(this, _ActionsManager_actions, actions !== null && actions !== void 0 ? actions : {}, "f");
+    }
+    get actions() {
+        return __classPrivateFieldGet(this, _ActionsManager_actions, "f");
+    }
+    action(actionName) {
+        return __classPrivateFieldGet(this, _ActionsManager_actions, "f")[actionName];
+    }
+    setActions(actions) {
+        __classPrivateFieldSet(this, _ActionsManager_actions, actions, "f");
+        return this;
+    }
+}
+_ActionsManager_actions = new WeakMap();

package/build/esm/core/ContentHandler.d.ts

@@ -0,0 +1,13 @@
+import type { EditorView } from 'prosemirror-view';
+import type { ContentHandler, MarkupString } from '../common';
+import type { Parser } from './types/parser';
+export declare class WysiwygContentHandler implements ContentHandler {
+    #private;
+    constructor(view: EditorView, parser: Parser);
+    clear(): void;
+    replace(newMarkup: MarkupString): void;
+    prepend(markup: MarkupString): void;
+    append(markup: MarkupString): void;
+    moveCursor(position: 'start' | 'end'): void;
+    private appendContentTr;
+}

package/build/esm/core/ContentHandler.js

@@ -0,0 +1,67 @@
+var _WysiwygContentHandler_view, _WysiwygContentHandler_parser;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { Slice } from 'prosemirror-model';
+import { AllSelection, TextSelection } from 'prosemirror-state';
+export class WysiwygContentHandler {
+    constructor(view, parser) {
+        _WysiwygContentHandler_view.set(this, void 0);
+        _WysiwygContentHandler_parser.set(this, void 0);
+        __classPrivateFieldSet(this, _WysiwygContentHandler_view, view, "f");
+        __classPrivateFieldSet(this, _WysiwygContentHandler_parser, parser, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(__classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.tr
+            .setSelection(new AllSelection(__classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.doc))
+            .replaceSelection(Slice.empty));
+    }
+    replace(newMarkup) {
+        __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(__classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.tr
+            .setSelection(new AllSelection(__classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.doc))
+            .replaceSelection(new Slice(__classPrivateFieldGet(this, _WysiwygContentHandler_parser, "f").parse(newMarkup).content, 0, 0)));
+    }
+    prepend(markup) {
+        __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(__classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.tr.insert(0, __classPrivateFieldGet(this, _WysiwygContentHandler_parser, "f").parse(markup).content));
+    }
+    append(markup) {
+        var _a, _b;
+        let tr = __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.tr;
+        if (((_a = tr.doc.lastChild) === null || _a === void 0 ? void 0 : _a.type.name) === 'paragraph' && tr.doc.lastChild.childCount === 0) {
+            const pos = tr.doc.nodeSize - 3;
+            tr = tr.replaceWith(pos - 1, pos + 1, __classPrivateFieldGet(this, _WysiwygContentHandler_parser, "f").parse(markup));
+        }
+        else {
+            tr = this.appendContentTr(tr, markup);
+        }
+        if (((_b = tr.doc.lastChild) === null || _b === void 0 ? void 0 : _b.type.name) !== 'paragraph' || tr.doc.lastChild.childCount !== 0) {
+            tr = this.appendContentTr(tr, '');
+        }
+        __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(tr);
+    }
+    moveCursor(position) {
+        switch (position) {
+            case 'start': {
+                const { tr } = __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state;
+                __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(tr.setSelection(TextSelection.create(tr.doc, 1)));
+                break;
+            }
+            case 'end': {
+                const { lastChild } = __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state.doc;
+                const { tr } = __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").state;
+                const pos = tr.doc.nodeSize - 2;
+                if (!(lastChild === null || lastChild === void 0 ? void 0 : lastChild.isTextblock) && !(lastChild === null || lastChild === void 0 ? void 0 : lastChild.isText)) {
+                    this.appendContentTr(tr, '');
+                }
+                __classPrivateFieldGet(this, _WysiwygContentHandler_view, "f").dispatch(tr
+                    .setSelection(TextSelection.create(tr.doc, tr.mapping.map(pos) - 1))
+                    .scrollIntoView());
+                break;
+            }
+            default:
+                throw new Error('The "position" argument must be "start" or "end"');
+        }
+    }
+    appendContentTr(tr, markup) {
+        return tr.insert(tr.doc.nodeSize - 2, __classPrivateFieldGet(this, _WysiwygContentHandler_parser, "f").parse(markup).content);
+    }
+}
+_WysiwygContentHandler_view = new WeakMap(), _WysiwygContentHandler_parser = new WeakMap();

package/build/esm/core/Editor.d.ts

@@ -0,0 +1,49 @@
+import type { PresetName } from 'markdown-it';
+import type { CommonEditor, MarkupString } from '../common';
+import type { ActionStorage } from './types/actions';
+import type { Extension } from './types/extension';
+import type { Parser } from './types/parser';
+import type { Serializer } from './types/serializer';
+declare type OnChange = (editor: WysiwygEditor) => void;
+export declare type WysiwygEditorOptions = {
+    domElem?: Element;
+    /** markdown markup */
+    initialContent?: string;
+    extensions?: Extension;
+    /** @default 'default' */
+    mdPreset?: PresetName;
+    allowHTML?: boolean;
+    linkify?: boolean;
+    linkifyTlds?: string | string[];
+    /** Call on any state change (move cursor, change selection, etc...) */
+    onChange?: OnChange;
+    /** Call only if document change */
+    onDocChange?: OnChange;
+};
+export declare class WysiwygEditor implements CommonEditor, ActionStorage {
+    #private;
+    get dom(): HTMLElement;
+    get serializer(): Serializer;
+    get parser(): Parser;
+    get actions(): WysiwygEditor.Actions;
+    constructor({ domElem, initialContent, extensions, allowHTML, mdPreset, linkify, linkifyTlds, onChange, onDocChange, }: WysiwygEditorOptions);
+    action<T extends keyof WysiwygEditor.Actions>(actionName: T): WysiwygEditor.Actions[T];
+    focus(): void;
+    hasFocus(): boolean;
+    getValue(): MarkupString;
+    isEmpty(): boolean;
+    clear(): void;
+    replace(newMarkup: MarkupString): void;
+    prepend(markup: MarkupString): void;
+    append(markup: MarkupString): void;
+    moveCursor(position: 'start' | 'end'): void;
+    destroy(): void;
+    private tryOnChange;
+}
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+        }
+    }
+}
+export {};

package/build/esm/core/Editor.js

@@ -0,0 +1,112 @@
+var _WysiwygEditor_view, _WysiwygEditor_serializer, _WysiwygEditor_parser, _WysiwygEditor_actions, _WysiwygEditor_contentHandler;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { WysiwygContentHandler } from './ContentHandler';
+import { ExtensionsManager } from './ExtensionsManager';
+import { bindActions } from './utils/actions';
+import { logTransactionMetrics } from './utils/metrics';
+export class WysiwygEditor {
+    constructor({ domElem, initialContent = '', extensions = () => { }, allowHTML, mdPreset, linkify, linkifyTlds, onChange, onDocChange, }) {
+        _WysiwygEditor_view.set(this, void 0);
+        _WysiwygEditor_serializer.set(this, void 0);
+        _WysiwygEditor_parser.set(this, void 0);
+        _WysiwygEditor_actions.set(this, void 0);
+        _WysiwygEditor_contentHandler.set(this, void 0);
+        const { schema, markupParser: parser, serializer, nodeViews, markViews, plugins, rawActions, actions, } = ExtensionsManager.process(extensions, {
+            // "breaks" option only affects the renderer, but not the parser
+            mdOpts: { html: allowHTML, linkify, breaks: true, preset: mdPreset },
+            linkifyTlds,
+        });
+        const state = EditorState.create({
+            schema,
+            doc: parser.parse(initialContent),
+            plugins,
+        });
+        const thisOnChange = () => this.tryOnChange(onChange);
+        const thisOnDocChange = () => this.tryOnChange(onDocChange);
+        __classPrivateFieldSet(this, _WysiwygEditor_view, new EditorView(domElem !== null && domElem !== void 0 ? domElem : null, {
+            state,
+            nodeViews,
+            markViews,
+            dispatchTransaction(tr) {
+                const newState = this.state.apply(tr);
+                // @ts-expect-error
+                this.updateState(newState);
+                thisOnChange();
+                if (tr.docChanged) {
+                    thisOnDocChange();
+                }
+                logTransactionMetrics(tr);
+            },
+        }), "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_actions, actions.setActions(bindActions(rawActions)(__classPrivateFieldGet(this, _WysiwygEditor_view, "f"))), "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_serializer, serializer, "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_parser, parser, "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_contentHandler, new WysiwygContentHandler(__classPrivateFieldGet(this, _WysiwygEditor_view, "f"), parser), "f");
+    }
+    get dom() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").dom;
+    }
+    get serializer() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_serializer, "f");
+    }
+    get parser() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_parser, "f");
+    }
+    get actions() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_actions, "f").actions;
+    }
+    /** @internal used for prosemirror-dev-tools in demo */
+    get view() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f");
+    }
+    action(actionName) {
+        return __classPrivateFieldGet(this, _WysiwygEditor_actions, "f").action(actionName);
+    }
+    focus() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").focus();
+    }
+    hasFocus() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").hasFocus();
+    }
+    getValue() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_serializer, "f").serialize(__classPrivateFieldGet(this, _WysiwygEditor_view, "f").state.doc);
+    }
+    isEmpty() {
+        var _a;
+        const { doc } = __classPrivateFieldGet(this, _WysiwygEditor_view, "f").state;
+        return (doc.childCount === 1 &&
+            ((_a = doc.firstChild) === null || _a === void 0 ? void 0 : _a.type.name) === 'paragraph' &&
+            doc.firstChild.childCount === 0);
+    }
+    clear() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").clear();
+    }
+    replace(newMarkup) {
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").replace(newMarkup);
+    }
+    prepend(markup) {
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").prepend(markup);
+    }
+    append(markup) {
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").append(markup);
+    }
+    moveCursor(position) {
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").moveCursor(position);
+    }
+    destroy() {
+        __classPrivateFieldGet(this, _WysiwygEditor_view, "f").destroy();
+    }
+    tryOnChange(cb) {
+        if (cb) {
+            try {
+                cb(this);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+}
+_WysiwygEditor_view = new WeakMap(), _WysiwygEditor_serializer = new WeakMap(), _WysiwygEditor_parser = new WeakMap(), _WysiwygEditor_actions = new WeakMap(), _WysiwygEditor_contentHandler = new WeakMap();

package/build/esm/core/ExtensionBuilder.d.ts

@@ -0,0 +1,71 @@
+import type MarkdownIt from 'markdown-it';
+import { inputRules } from 'prosemirror-inputrules';
+import type { Plugin } from 'prosemirror-state';
+import type { ActionSpec } from './types/actions';
+import type { Extension, ExtensionDeps, ExtensionMarkSpec, ExtensionNodeSpec, ExtensionSpec, ExtensionWithOptions } from './types/extension';
+import type { Keymap } from './types/keymap';
+declare type InputRulesConfig = Parameters<typeof inputRules>[0];
+declare type ConfigureMdParams = {
+    /**
+     * Apply this configurtion to text parser
+     *
+     * @default true
+     */
+    text?: boolean;
+    /**
+     * Apply this configurtion to markup parser
+     *
+     * @default true
+     */
+    markup?: boolean;
+};
+declare type ConfigureMdCallback = (md: MarkdownIt) => MarkdownIt;
+declare type AddPmNodeCallback = () => ExtensionNodeSpec;
+declare type AddPmMarkCallback = () => ExtensionMarkSpec;
+declare type AddPmPluginCallback = (deps: ExtensionDeps) => Plugin | Plugin[];
+declare type AddPmKeymapCallback = (deps: ExtensionDeps) => Keymap;
+declare type AddPmInputRulesCallback = (deps: ExtensionDeps) => InputRulesConfig;
+declare type AddActionCallback = (deps: ExtensionDeps) => ActionSpec;
+declare enum Priority {
+    Highest = 1000000,
+    VeryHigh = 100000,
+    High = 10000,
+    Medium = 1000,
+    Low = 100,
+    VeryLow = 10,
+    Lowest = 0
+}
+declare type BuilderContext<T extends object> = {
+    has(key: keyof T): boolean;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): BuilderContext<T>;
+};
+declare global {
+    namespace WysiwygEditor {
+        interface Context {
+        }
+    }
+}
+export declare class ExtensionBuilder {
+    #private;
+    static createContext(): BuilderContext<WysiwygEditor.Context>;
+    static readonly Priority: typeof Priority;
+    readonly Priority: typeof Priority;
+    /** @deprecated use `ExtensionBuilder.Priority` instead */
+    static readonly PluginPriority: typeof Priority;
+    /** @deprecated use `builder.Priority` instead */
+    readonly PluginPriority: typeof Priority;
+    readonly context: BuilderContext<WysiwygEditor.Context>;
+    constructor(context?: BuilderContext<WysiwygEditor.Context>);
+    use(extension: Extension): this;
+    use<T>(extension: ExtensionWithOptions<T>, options: T): this;
+    configureMd(cb: ConfigureMdCallback, params?: ConfigureMdParams): this;
+    addNode(name: string, cb: AddPmNodeCallback): this;
+    addMark(name: string, cb: AddPmMarkCallback, priority?: Priority): this;
+    addPlugin(cb: AddPmPluginCallback, priority?: Priority): this;
+    addKeymap(cb: AddPmKeymapCallback, priority?: Priority): this;
+    addInputRules(cb: AddPmInputRulesCallback, priority?: Priority): this;
+    addAction(name: string, cb: AddActionCallback): this;
+    build(): ExtensionSpec;
+}
+export {};

package/build/esm/core/ExtensionBuilder.js

@@ -0,0 +1,137 @@
+var _ExtensionBuilder_confMdCbs, _ExtensionBuilder_nodeSpecs, _ExtensionBuilder_markSpecs, _ExtensionBuilder_plugins, _ExtensionBuilder_actions;
+import { __classPrivateFieldGet } from "tslib";
+import OrderedMap from 'orderedmap'; // eslint-disable-line import/no-extraneous-dependencies
+import { inputRules } from 'prosemirror-inputrules';
+import { keymap } from 'prosemirror-keymap';
+var Priority;
+(function (Priority) {
+    Priority[Priority["Highest"] = 1000000] = "Highest";
+    Priority[Priority["VeryHigh"] = 100000] = "VeryHigh";
+    Priority[Priority["High"] = 10000] = "High";
+    Priority[Priority["Medium"] = 1000] = "Medium";
+    Priority[Priority["Low"] = 100] = "Low";
+    Priority[Priority["VeryLow"] = 10] = "VeryLow";
+    Priority[Priority["Lowest"] = 0] = "Lowest";
+})(Priority || (Priority = {}));
+const DEFAULT_PRIORITY = Priority.Medium;
+export class ExtensionBuilder {
+    constructor(context) {
+        this.Priority = ExtensionBuilder.Priority;
+        /** @deprecated use `builder.Priority` instead */
+        this.PluginPriority = ExtensionBuilder.PluginPriority;
+        /* eslint-enable @typescript-eslint/member-ordering */
+        _ExtensionBuilder_confMdCbs.set(this, []);
+        _ExtensionBuilder_nodeSpecs.set(this, {});
+        _ExtensionBuilder_markSpecs.set(this, {});
+        _ExtensionBuilder_plugins.set(this, []);
+        _ExtensionBuilder_actions.set(this, []);
+        this.context = context !== null && context !== void 0 ? context : ExtensionBuilder.createContext();
+    }
+    static createContext() {
+        return new Map();
+    }
+    use(extension, ...params) {
+        extension(this, ...params);
+        return this;
+    }
+    configureMd(cb, params = {}) {
+        var _a, _b;
+        __classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").push({
+            cb,
+            params: {
+                text: (_a = params.text) !== null && _a !== void 0 ? _a : true,
+                markup: (_b = params.markup) !== null && _b !== void 0 ? _b : true,
+            },
+        });
+        return this;
+    }
+    addNode(name, cb) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name]) {
+            throw new Error(`ProseMirror node with this name "${name}" already exist`);
+        }
+        __classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name] = { name, cb };
+        return this;
+    }
+    addMark(name, cb, priority = DEFAULT_PRIORITY) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name]) {
+            throw new Error(`ProseMirror mark with this name "${name}" already exist`);
+        }
+        __classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name] = { name, cb, priority };
+        return this;
+    }
+    addPlugin(cb, priority = DEFAULT_PRIORITY) {
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb, priority });
+        return this;
+    }
+    addKeymap(cb, priority = DEFAULT_PRIORITY) {
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => keymap(cb(...args)), priority });
+        return this;
+    }
+    addInputRules(cb, priority = DEFAULT_PRIORITY) {
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => inputRules(cb(...args)), priority });
+        return this;
+    }
+    addAction(name, cb) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").some(([actionName]) => actionName === name)) {
+            throw new Error(`[Markdown Wysiwyg Editor] action with this name "${name}" already exist`);
+        }
+        __classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").push([name, cb]);
+        return this;
+    }
+    build() {
+        const confMd = __classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").slice();
+        const nodes = Object.assign({}, __classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f"));
+        const marks = Object.assign({}, __classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f"));
+        const plugins = __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").slice();
+        const actions = __classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").slice();
+        return {
+            configureMd: (md, parserType) => confMd.reduce((pMd, { cb, params }) => {
+                if (parserType === 'text' && params.text) {
+                    return cb(pMd);
+                }
+                if (parserType === 'markup' && params.markup) {
+                    return cb(pMd);
+                }
+                return pMd;
+            }, md),
+            nodes: () => {
+                let map = OrderedMap.from({});
+                for (const { name, cb } of Object.values(nodes)) {
+                    map = map.addToEnd(name, cb());
+                }
+                return map;
+            },
+            marks: () => {
+                // The order of marks in schema is important when serializing pm-document to DOM or markup
+                // https://discuss.prosemirror.net/t/marks-priority/4463
+                const sortedMarks = Object.values(marks).sort((a, b) => b.priority - a.priority);
+                let map = OrderedMap.from({});
+                for (const { name, cb } of sortedMarks) {
+                    map = map.addToEnd(name, cb());
+                }
+                return map;
+            },
+            plugins: (deps) => {
+                return plugins
+                    .sort((a, b) => b.priority - a.priority)
+                    .reduce((acc, { cb }) => {
+                    const res = cb(deps);
+                    if (Array.isArray(res))
+                        acc.push(...res);
+                    else
+                        acc.push(res);
+                    return acc;
+                }, []);
+            },
+            actions: (deps) => actions.reduce((obj, [name, cb]) => {
+                obj[name] = cb(deps);
+                return obj;
+            }, {}),
+        };
+    }
+}
+_ExtensionBuilder_confMdCbs = new WeakMap(), _ExtensionBuilder_nodeSpecs = new WeakMap(), _ExtensionBuilder_markSpecs = new WeakMap(), _ExtensionBuilder_plugins = new WeakMap(), _ExtensionBuilder_actions = new WeakMap();
+/* eslint-disable @typescript-eslint/member-ordering */
+ExtensionBuilder.Priority = Priority;
+/** @deprecated use `ExtensionBuilder.Priority` instead */
+ExtensionBuilder.PluginPriority = ExtensionBuilder.Priority;

package/build/esm/core/ExtensionsManager.d.ts

@@ -0,0 +1,49 @@
+import MarkdownIt, { PresetName } from 'markdown-it';
+import type { Plugin } from 'prosemirror-state';
+import { ActionsManager } from './ActionsManager';
+import type { ActionSpec } from './types/actions';
+import type { Extension, ExtensionDeps } from './types/extension';
+import type { MarkViewConstructor, NodeViewConstructor } from './types/node-views';
+declare type ExtensionsManagerParams = {
+    extensions: Extension;
+    options?: ExtensionsManagerOptions;
+};
+declare type ExtensionsManagerOptions = {
+    mdOpts?: MarkdownIt.Options & {
+        preset?: PresetName;
+    };
+    linkifyTlds?: string | string[];
+};
+export declare class ExtensionsManager {
+    #private;
+    static process(extensions: Extension, options: ExtensionsManagerOptions): {
+        actions: ActionsManager;
+        rawActions: Record<string, ActionSpec>;
+        plugins: Plugin<any>[];
+        nodeViews: Record<string, NodeViewConstructor>;
+        markViews: Record<string, MarkViewConstructor>;
+        schema: import("prosemirror-model").Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
+    };
+    constructor({ extensions, options }: ExtensionsManagerParams);
+    build(): {
+        actions: ActionsManager;
+        rawActions: Record<string, ActionSpec>;
+        plugins: Plugin<any>[];
+        nodeViews: Record<string, NodeViewConstructor>;
+        markViews: Record<string, MarkViewConstructor>;
+        schema: import("prosemirror-model").Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
+    };
+    buildDeps(): ExtensionDeps;
+    private processExtensions;
+    private processNode;
+    private processMark;
+    private createDeps;
+    private createDerived;
+}
+export {};