@kerebron/extension-lsp 0.4.1

package/esm/editor/src/ExtensionManager.d.ts

@@ -0,0 +1,32 @@
+import { Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { NodeViewConstructor } from 'prosemirror-view';
+import { Converter, Extension } from './Extension.js';
+import { AnyExtension, AnyExtensionOrReq } from './types.js';
+import { CoreEditor } from './CoreEditor.js';
+import { Mark } from './Mark.js';
+import { Node } from './Node.js';
+import { type CommandManager } from './commands/CommandManager.js';
+export declare function findDuplicates(items: any[]): any[];
+export declare function splitExtensions(extensions: Iterable<AnyExtension>): {
+    baseExtensions: Extension[];
+    nodeExtensions: Node[];
+    markExtensions: Mark[];
+};
+export declare class ExtensionManager {
+    private editor;
+    private commandManager;
+    readonly schema: Schema;
+    private extensions;
+    readonly plugins: Plugin[];
+    readonly nodeViews: Record<string, NodeViewConstructor>;
+    converters: Record<string, Converter>;
+    private debug;
+    constructor(extensions: AnyExtensionOrReq[], editor: CoreEditor, commandManager: CommandManager);
+    getExtension<T extends Extension>(name: string): T | undefined;
+    private initPlugins;
+    private setupExtensions;
+    getSchemaByResolvedExtensions(editor: CoreEditor): Schema;
+    created(): void;
+}
+//# sourceMappingURL=ExtensionManager.d.ts.map

package/esm/editor/src/ExtensionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.d.ts","sourceRoot":"","sources":["../../../src/editor/src/ExtensionManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AASjC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGnE,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAIlD;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC;;;;EAgBjE;AAED,qBAAa,gBAAgB;IAazB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IAbxB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAgC;IAClD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAM;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAM;IAEtD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAM;IAElD,OAAO,CAAC,KAAK,CAAQ;gBAGnB,UAAU,EAAE,iBAAiB,EAAE,EACvB,MAAM,EAAE,UAAU,EAClB,cAAc,EAAE,cAAc;IAcxC,YAAY,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAY9D,OAAO,CAAC,WAAW;IAkHnB,OAAO,CAAC,eAAe;IAwEvB,6BAA6B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAkDzD,OAAO;CAOR"}

package/esm/editor/src/ExtensionManager.js

@@ -0,0 +1,260 @@
+import { Schema } from 'prosemirror-model';
+import { InputRulesPlugin, } from './plugins/input-rules/InputRulesPlugin.js';
+import { KeymapPlugin } from './plugins/keymap/keymap.js';
+import { firstCommand } from './commands/mod.js';
+import { addAttributesToSchema } from './utilities/getHtmlAttributes.js';
+import { TrackSelecionPlugin } from './plugins/TrackSelecionPlugin.js';
+export function findDuplicates(items) {
+    const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+    return Array.from(new Set(filtered));
+}
+export function splitExtensions(extensions) {
+    const baseExtensions = Array.from(extensions).filter((extension) => extension.type === 'extension');
+    const nodeExtensions = Array.from(extensions).filter((extension) => extension.type === 'node');
+    const markExtensions = Array.from(extensions).filter((extension) => extension.type === 'mark');
+    return {
+        baseExtensions,
+        nodeExtensions,
+        markExtensions,
+    };
+}
+export class ExtensionManager {
+    constructor(extensions, editor, commandManager) {
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "commandManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: commandManager
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "nodeViews", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "converters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.setupExtensions(new Set(extensions));
+        this.schema = this.getSchemaByResolvedExtensions(editor);
+        const event = new CustomEvent('schema:ready', {
+            detail: {
+                editor,
+                schema: this.schema,
+            },
+        });
+        editor.dispatchEvent(event);
+    }
+    getExtension(name) {
+        const { nodeExtensions, markExtensions, baseExtensions } = splitExtensions(this.extensions);
+        for (const extension of baseExtensions) {
+            if (extension.name === name) {
+                return extension;
+            }
+        }
+    }
+    initPlugins() {
+        const inputRules = [];
+        const keyBindings = new Map();
+        const mergeShortcuts = (toInsert, extName) => {
+            for (const key in toInsert) {
+                if (!toInsert[key]) {
+                    continue;
+                }
+                const commandFactory = this.commandManager.commandFactories[toInsert[key]];
+                if (!commandFactory) {
+                    console.warn(`No command constructor: ${toInsert[key]}`);
+                    continue;
+                }
+                const command = commandFactory();
+                const keyBinding = keyBindings.get(key);
+                if (keyBinding) {
+                    keyBindings.set(key, firstCommand(command, keyBinding));
+                }
+                else {
+                    keyBindings.set(key, command);
+                }
+            }
+        };
+        let converters = {};
+        for (const extension of this.extensions) {
+            extension.setEditor(this.editor);
+            if (extension.type === 'node') {
+                const nodeType = this.schema.nodes[extension.name];
+                inputRules.push(...extension.getInputRules(nodeType));
+                this.plugins.push(...extension.getProseMirrorPlugins());
+                this.commandManager.mergeCommandFactories(extension.getCommandFactories(this.editor, nodeType), extension.name);
+                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
+                converters = {
+                    ...converters,
+                    ...extension.getConverters(this.editor, this.schema),
+                };
+                const nodeView = extension.getNodeView(this.editor);
+                if (nodeView) {
+                    this.nodeViews[extension.name] = nodeView;
+                }
+            }
+            if (extension.type === 'mark') {
+                const markType = this.schema.marks[extension.name];
+                inputRules.push(...extension.getInputRules(markType));
+                this.commandManager.mergeCommandFactories(extension.getCommandFactories(this.editor, markType), extension.name);
+                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
+            }
+            if (extension.type === 'extension') {
+                this.plugins.push(...extension.getProseMirrorPlugins());
+                this.commandManager.mergeCommandFactories(extension.getCommandFactories(this.editor), extension.name);
+                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
+                converters = {
+                    ...converters,
+                    ...extension.getConverters(this.editor, this.schema),
+                };
+            }
+        }
+        if (this.debug) {
+            for (const key in keyBindings) {
+                const keyBinding = keyBindings.get(key);
+                if (!keyBinding) {
+                    continue;
+                }
+                const wrapperCommand = (state, dispatch, view) => {
+                    console.debug(`Key: ${key}`);
+                    return true;
+                };
+                keyBindings.set(key, firstCommand(wrapperCommand, keyBinding));
+            }
+        }
+        this.converters = converters;
+        this.plugins.push(new InputRulesPlugin(inputRules));
+        this.plugins.push(new KeymapPlugin(Object.fromEntries(keyBindings)));
+        this.plugins.push(new TrackSelecionPlugin(this.editor));
+    }
+    setupExtensions(extensions) {
+        const allExtensions = new Map();
+        const createMap = (extensions) => {
+            for (const extension of extensions) {
+                if ('name' in extension) {
+                    allExtensions.set(extension.name, extension);
+                }
+                if ('requires' in extension) {
+                    const childExtensions = Array.from(extension.requires).filter((e) => typeof e !== 'string');
+                    createMap(new Set(childExtensions));
+                }
+            }
+        };
+        createMap(extensions);
+        const initialized = new Set();
+        const initializeExtension = (extension) => {
+            console.info(`Initialize ${extension.type} ${extension.name}`);
+            this.extensions.add(extension);
+        };
+        function recursiveInitializeExtension(extension) {
+            if ('name' in extension && initialized.has(extension.name)) {
+                return;
+            }
+            if ('requires' in extension) {
+                const requires = extension.requires || [];
+                const requireNames = requires.map((e) => typeof e === 'string' ? e : ('name' in e ? e.name : ''));
+                for (const require of requireNames) {
+                    if (!initialized.has(require)) {
+                        const requiredExtension = allExtensions.get(require);
+                        if (!requiredExtension) {
+                            throw new Error(`Required extension for (${'name' in extension ? extension.name : extension}) not found: ${require}`);
+                        }
+                        recursiveInitializeExtension(requiredExtension);
+                    }
+                }
+            }
+            if ('name' in extension) {
+                initializeExtension(extension);
+                initialized.add(extension.name);
+                allExtensions.delete(extension.name);
+            }
+        }
+        for (const extension of allExtensions.values()) {
+            recursiveInitializeExtension(extension);
+        }
+        if (allExtensions.size > 0) {
+            throw new Error('Not all extensions initialized: ' +
+                Array.from(allExtensions.keys()).join(', '));
+        }
+    }
+    getSchemaByResolvedExtensions(editor) {
+        const { nodeExtensions, markExtensions, baseExtensions } = splitExtensions(this.extensions);
+        for (const extension of baseExtensions) {
+            if (Array.isArray(extension.conflicts)) {
+                for (const name of extension.conflicts) {
+                    if (this.getExtension(name)) {
+                        throw new Error(`Extension conflict: ${extension.name} vs ${name}`);
+                    }
+                }
+            }
+        }
+        const nodes = {};
+        for (const extension of nodeExtensions) {
+            nodes[extension.name] = extension.getNodeSpec();
+            addAttributesToSchema(nodes[extension.name], extension);
+        }
+        const marks = {};
+        for (const extension of markExtensions) {
+            marks[extension.name] = extension.getMarkSpec();
+            addAttributesToSchema(marks[extension.name], extension);
+        }
+        const spec = {
+            topNode: this.editor.config.topNode || 'doc',
+            nodes,
+            marks,
+        };
+        for (const extension of baseExtensions) {
+            if ('setupSpec' in baseExtensions) {
+                extension.setupSpec(spec);
+            }
+        }
+        const event = new CustomEvent('schema:spec', {
+            detail: {
+                editor,
+                spec,
+            },
+        });
+        editor.dispatchEvent(event);
+        return new Schema(spec);
+    }
+    created() {
+        this.initPlugins();
+        for (const extension of this.extensions) {
+            extension.created();
+        }
+    }
+}

package/esm/editor/src/Mark.d.ts

@@ -0,0 +1,23 @@
+import type { MarkSpec, MarkType } from 'prosemirror-model';
+import type { InputRule } from './plugins/input-rules/InputRulesPlugin.js';
+import type { CoreEditor } from './CoreEditor.js';
+import type { CommandFactories, CommandShortcuts } from './commands/mod.js';
+import { Attribute } from './types.js';
+export interface MarkConfig {
+    [key: string]: any;
+}
+export declare abstract class Mark {
+    protected config: Partial<MarkConfig>;
+    readonly type = "mark";
+    name: string;
+    protected editor: CoreEditor;
+    readonly attributes: Record<string, Attribute<any>>;
+    constructor(config?: Partial<MarkConfig>);
+    setEditor(editor: CoreEditor): void;
+    created(): void;
+    getMarkSpec(): MarkSpec;
+    getInputRules(type: MarkType): InputRule[];
+    getCommandFactories(editor: CoreEditor, type: MarkType): Partial<CommandFactories>;
+    getKeyboardShortcuts(editor: CoreEditor): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=Mark.d.ts.map

package/esm/editor/src/Mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mark.d.ts","sourceRoot":"","sources":["../../../src/editor/src/Mark.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,WAAW,UAAU;IAEzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,8BAAsB,IAAI;IAOL,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IANxD,QAAQ,CAAC,IAAI,UAAU;IACvB,IAAI,EAAE,MAAM,CAAU;IACtB,SAAS,CAAC,MAAM,EAAG,UAAU,CAAC;IAE9B,SAAgB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM;gBAEnC,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAE7D,SAAS,CAAC,MAAM,EAAE,UAAU;IAI5B,OAAO;IAGP,WAAW,IAAI,QAAQ;IAIvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAI1C,mBAAmB,CACjB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAI5B,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAGpE"}

package/esm/editor/src/Mark.js

@@ -0,0 +1,51 @@
+export class Mark {
+    constructor(config = {}) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'mark'
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'node'
+        });
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "attributes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    setEditor(editor) {
+        this.editor = editor;
+    }
+    created() {
+    }
+    getMarkSpec() {
+        throw new Error('MarkSpec not defined: ' + this.name);
+    }
+    getInputRules(type) {
+        return [];
+    }
+    getCommandFactories(editor, type) {
+        return {};
+    }
+    getKeyboardShortcuts(editor) {
+        return {};
+    }
+}

package/esm/editor/src/Node.d.ts

@@ -0,0 +1,32 @@
+import type { NodeSpec, NodeType, Schema } from 'prosemirror-model';
+import type { NodeViewConstructor } from 'prosemirror-view';
+import type { Plugin } from 'prosemirror-state';
+import type { InputRule } from './plugins/input-rules/InputRulesPlugin.js';
+import type { CoreEditor } from './CoreEditor.js';
+import type { Command, CommandShortcuts } from './commands/mod.js';
+import type { Converter } from './Extension.js';
+import { Attribute } from './types.js';
+export interface NodeConfig {
+    [key: string]: any;
+}
+export interface CommandFactories {
+    [key: string]: () => Command;
+}
+export declare abstract class Node {
+    protected config: Partial<NodeConfig>;
+    readonly type = "node";
+    name: string;
+    protected editor: CoreEditor;
+    readonly attributes: Record<string, Attribute<any>>;
+    constructor(config?: Partial<NodeConfig>);
+    setEditor(editor: CoreEditor): void;
+    created(): void;
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getProseMirrorPlugins(): Plugin[];
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(editor: CoreEditor): Partial<CommandShortcuts>;
+    getNodeView(editor: CoreEditor): NodeViewConstructor | undefined;
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+}
+//# sourceMappingURL=Node.d.ts.map

package/esm/editor/src/Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../../src/editor/src/Node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,WAAW,UAAU;IAEzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,OAAO,CAAC;CAC9B;AAED,8BAAsB,IAAI;IAOL,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IANxD,QAAQ,CAAC,IAAI,UAAU;IACvB,IAAI,EAAE,MAAM,CAAU;IACtB,SAAS,CAAC,MAAM,EAAG,UAAU,CAAC;IAE9B,SAAgB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM;gBAEnC,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAE7D,SAAS,CAAC,MAAM,EAAE,UAAU;IAI5B,OAAO;IAGP,WAAW,IAAI,QAAQ;IAIvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAI1C,qBAAqB,IAAI,MAAM,EAAE;IAIjC,mBAAmB,CACjB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAI5B,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAInE,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,mBAAmB,GAAG,SAAS;IAIhE,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CAG7E"}

package/esm/editor/src/Node.js

@@ -0,0 +1,60 @@
+export class Node {
+    constructor(config = {}) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'node'
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'node'
+        });
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "attributes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    setEditor(editor) {
+        this.editor = editor;
+    }
+    created() {
+    }
+    getNodeSpec() {
+        throw new Error('NodeSpec not defined: ' + this.name);
+    }
+    getInputRules(type) {
+        return [];
+    }
+    getProseMirrorPlugins() {
+        return [];
+    }
+    getCommandFactories(editor, type) {
+        return {};
+    }
+    getKeyboardShortcuts(editor) {
+        return {};
+    }
+    getNodeView(editor) {
+        return undefined;
+    }
+    getConverters(editor, schema) {
+        return {};
+    }
+}

package/esm/editor/src/commands/CommandManager.d.ts

@@ -0,0 +1,23 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { CoreEditor } from '../CoreEditor.js';
+import type { ChainedCommands, CommandFactories, CommandFactory } from './types.js';
+type CommandRunner = (...args: any[]) => boolean;
+export declare class CommandManager {
+    private editor;
+    readonly commandFactories: {
+        [key: string]: CommandFactory;
+    };
+    readonly run: {
+        [key: string]: CommandRunner;
+    };
+    private debug;
+    constructor(editor: CoreEditor);
+    mergeCommandFactories(toInsert: Partial<CommandFactories>, extName: string): void;
+    get state(): EditorState;
+    get chain(): () => ChainedCommands;
+    get can(): () => ChainedCommands;
+    createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
+    createCan(startTr?: Transaction): ChainedCommands;
+}
+export {};
+//# sourceMappingURL=CommandManager.d.ts.map

package/esm/editor/src/commands/CommandManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandManager.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/commands/CommandManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EACV,eAAe,EAEf,gBAAgB,EAChB,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB,KAAK,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;AAEjD,qBAAa,cAAc;IAOvB,OAAO,CAAC,MAAM;IANhB,SAAgB,gBAAgB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAM;IACzE,SAAgB,GAAG,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;KAAE,CAAM;IAE3D,OAAO,CAAC,KAAK,CAAQ;gBAGX,MAAM,EAAE,UAAU;IAOrB,qBAAqB,CAC1B,QAAQ,EAAE,OAAO,CAAC,gBAAgB,CAAC,EACnC,OAAO,EAAE,MAAM;IA4CjB,IAAI,KAAK,IAAI,WAAW,CAEvB;IAED,IAAI,KAAK,IAAI,MAAM,eAAe,CAEjC;IAED,IAAI,GAAG,IAAI,MAAM,eAAe,CAE/B;IAEM,WAAW,CAChB,OAAO,CAAC,EAAE,WAAW,EACrB,cAAc,UAAO,GACpB,eAAe;IA4CX,SAAS,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,eAAe;CAGzD"}

package/esm/editor/src/commands/CommandManager.js

@@ -0,0 +1,118 @@
+import { EditorView } from 'prosemirror-view';
+import { createChainableState } from './createChainableState.js';
+import { baseCommandFactories } from './baseCommandFactories.js';
+import { keyCommandFactories } from './keyCommandFactories.js';
+import { replaceCommandFactories } from './replaceCommandFactories.js';
+export class CommandManager {
+    constructor(editor) {
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "commandFactories", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "run", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.mergeCommandFactories(baseCommandFactories, 'baseCommand');
+        this.mergeCommandFactories(keyCommandFactories, 'key');
+        this.mergeCommandFactories(replaceCommandFactories, 'replace');
+    }
+    mergeCommandFactories(toInsert, extName) {
+        for (const key in toInsert) {
+            const commandFactory = toInsert[key];
+            if (!commandFactory) {
+                continue;
+            }
+            if (this.debug) {
+                const wrappedFactory = (...args) => {
+                    const realCommand = commandFactory(...args);
+                    const command = (state, dispatch, view) => {
+                        if (dispatch) {
+                            console.debug(`Command: ${extName}.${key}`);
+                        }
+                        return realCommand(state, dispatch, view);
+                    };
+                    return command;
+                };
+                this.commandFactories[key] = wrappedFactory;
+            }
+            else {
+                this.commandFactories[key] = commandFactory;
+            }
+        }
+        for (const key in this.commandFactories) {
+            const factory = this.commandFactories[key];
+            this.run[key] = (...args) => {
+                const command = factory(...args);
+                const state = this.editor.state;
+                const view = this.editor.view;
+                if (view instanceof EditorView) {
+                    return command(state, view.dispatch, view);
+                }
+                else {
+                    return command(state, view.dispatch);
+                }
+            };
+        }
+    }
+    get state() {
+        return this.editor.state;
+    }
+    get chain() {
+        return () => this.createChain();
+    }
+    get can() {
+        return () => this.createCan();
+    }
+    createChain(startTr, shouldDispatch = true) {
+        const { commandFactories, editor, state } = this;
+        const { view } = editor;
+        const callbacks = [];
+        const hasStartTransaction = !!startTr;
+        const tr = startTr || state.tr;
+        const chainedState = createChainableState(tr, state);
+        const fakeDispatch = () => undefined;
+        const chain = {
+            ...Object.fromEntries(Object.entries(commandFactories).map(([name, commandFactory]) => {
+                const chainedCommand = (...args) => {
+                    const command = commandFactory(...args);
+                    const callback = command(chainedState, shouldDispatch ? fakeDispatch : undefined);
+                    callbacks.push(callback);
+                    return chain;
+                };
+                return [name, chainedCommand];
+            })),
+            run: () => {
+                if (!hasStartTransaction &&
+                    shouldDispatch &&
+                    !tr.getMeta('preventDispatch')) {
+                    view.dispatch(tr);
+                }
+                return callbacks.every((callback) => callback === true);
+            },
+            chain: () => {
+                return this.createChain(tr, shouldDispatch);
+            },
+        };
+        return chain;
+    }
+    createCan(startTr) {
+        return this.createChain(startTr, false);
+    }
+}

package/esm/editor/src/commands/baseCommandFactories.d.ts

@@ -0,0 +1,3 @@
+import { CommandFactory } from './types.js';
+export declare const baseCommandFactories: Record<string, CommandFactory>;
+//# sourceMappingURL=baseCommandFactories.d.ts.map

package/esm/editor/src/commands/baseCommandFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseCommandFactories.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/commands/baseCommandFactories.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAgB,cAAc,EAAE,MAAM,YAAY,CAAC;AAo/B1D,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CA2B/D,CAAC"}