@kerebron/extension-menu 0.2.0 → 0.3.0

package/esm/editor/src/ExtensionManager.js

@@ -0,0 +1,272 @@
+import { Schema } from 'prosemirror-model';
+import { InputRulesPlugin, } from './plugins/input-rules/InputRulesPlugin.js';
+import { KeymapPlugin } from './plugins/keymap/keymap.js';
+import { chainCommands, } from './commands/mod.js';
+import { addAttributesToSchema } from './utilities/getHtmlAttributes.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) {
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        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: void 0
+        });
+        Object.defineProperty(this, "nodeViews", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "commandFactories", {
+            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);
+        this.plugins = this.getPlugins();
+    }
+    getExtension(name) {
+        const { nodeExtensions, markExtensions, baseExtensions } = splitExtensions(this.extensions);
+        for (const extension of baseExtensions) {
+            if (extension.name === name) {
+                return extension;
+            }
+        }
+    }
+    getPlugins() {
+        const plugins = [];
+        const inputRules = [];
+        const commands = new Map();
+        const keyBindings = new Map();
+        const mergeCommands = (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;
+                    };
+                    commands.set(key, wrappedFactory);
+                    this.commandFactories[key] = wrappedFactory;
+                }
+                else {
+                    commands.set(key, commandFactory);
+                    this.commandFactories[key] = commandFactory;
+                }
+            }
+        };
+        function mergeShortcuts(toInsert, extName) {
+            for (const key in toInsert) {
+                if (!toInsert[key]) {
+                    continue;
+                }
+                const commandFactory = commands.get(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, chainCommands(keyBinding, command));
+                }
+                else {
+                    keyBindings.set(key, command);
+                }
+            }
+        }
+        let converters = {};
+        for (const extension of this.extensions) {
+            if (extension.type === 'node') {
+                const nodeType = this.schema.nodes[extension.name];
+                inputRules.push(...extension.getInputRules(nodeType));
+                plugins.push(...extension.getProseMirrorPlugins(this.editor, this.schema));
+                mergeCommands(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();
+                if (nodeView) {
+                    this.nodeViews[extension.name] = nodeView;
+                }
+            }
+            if (extension.type === 'mark') {
+                const markType = this.schema.marks[extension.name];
+                inputRules.push(...extension.getInputRules(markType));
+                mergeCommands(extension.getCommandFactories(this.editor, markType), extension.name);
+                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
+            }
+            if (extension.type === 'extension') {
+                plugins.push(...extension.getProseMirrorPlugins(this.editor, this.schema));
+                mergeCommands(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, chainCommands(wrapperCommand, keyBinding));
+            }
+        }
+        this.converters = converters;
+        plugins.push(new InputRulesPlugin(inputRules));
+        plugins.push(new KeymapPlugin(Object.fromEntries(keyBindings)));
+        return plugins;
+    }
+    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 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);
+        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.options.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);
+    }
+}

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

@@ -0,0 +1,20 @@
+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;
+    readonly attributes: Record<string, Attribute<any>>;
+    constructor(config?: Partial<MarkConfig>);
+    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;IAML,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IALxD,QAAQ,CAAC,IAAI,UAAU;IACvB,IAAI,EAAE,MAAM,CAAU;IAEtB,SAAgB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM;gBAEnC,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAE7D,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,40 @@
+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, "attributes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    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,29 @@
+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;
+    readonly attributes: Record<string, Attribute<any>>;
+    constructor(config?: Partial<NodeConfig>);
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getProseMirrorPlugins(editor: CoreEditor, schema: Schema): Plugin[];
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(editor: CoreEditor): Partial<CommandShortcuts>;
+    getNodeView(): 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;IAML,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IALxD,QAAQ,CAAC,IAAI,UAAU;IACvB,IAAI,EAAE,MAAM,CAAU;IAEtB,SAAgB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM;gBAEnC,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAE7D,WAAW,IAAI,QAAQ;IAIvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAI1C,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAInE,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,IAAI,mBAAmB,GAAG,SAAS;IAI9C,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,49 @@
+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, "attributes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    getNodeSpec() {
+        throw new Error('NodeSpec not defined: ' + this.name);
+    }
+    getInputRules(type) {
+        return [];
+    }
+    getProseMirrorPlugins(editor, schema) {
+        return [];
+    }
+    getCommandFactories(editor, type) {
+        return {};
+    }
+    getKeyboardShortcuts(editor) {
+        return {};
+    }
+    getNodeView() {
+        return undefined;
+    }
+    getConverters(editor, schema) {
+        return {};
+    }
+}

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

@@ -0,0 +1,16 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { CoreEditor } from '../CoreEditor.js';
+import { ChainedCommands, CommandFactory } from './mod.js';
+export declare class CommandManager {
+    private editor;
+    private commandFactories;
+    constructor(editor: CoreEditor, commandFactories?: {
+        [key: string]: CommandFactory;
+    });
+    get state(): EditorState;
+    get chain(): () => ChainedCommands;
+    get can(): () => ChainedCommands;
+    createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
+    createCan(startTr?: Transaction): ChainedCommands;
+}
+//# 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":"AAAA,OAAO,EAAgB,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE3D,qBAAa,cAAc;IAEvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,gBAAgB;gBADhB,MAAM,EAAE,UAAU,EAClB,gBAAgB,GAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;KAAO;IAIlE,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,61 @@
+import { createChainableState } from './createChainableState.js';
+export class CommandManager {
+    constructor(editor, commandFactories = {}) {
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "commandFactories", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: commandFactories
+        });
+    }
+    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/createChainableState.d.ts

@@ -0,0 +1,3 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+export declare function createChainableState(transaction: Transaction, state: EditorState): EditorState;
+//# sourceMappingURL=createChainableState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createChainableState.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/commands/createChainableState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7D,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,WAAW,GACjB,WAAW,CA8Bb"}

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

@@ -0,0 +1,29 @@
+export function createChainableState(transaction, state) {
+    let { selection } = transaction;
+    let { doc } = transaction;
+    let { storedMarks } = transaction;
+    return {
+        ...state,
+        apply: state.apply.bind(state),
+        applyTransaction: state.applyTransaction.bind(state),
+        plugins: state.plugins,
+        schema: state.schema,
+        reconfigure: state.reconfigure.bind(state),
+        toJSON: state.toJSON.bind(state),
+        get storedMarks() {
+            return storedMarks;
+        },
+        get selection() {
+            return selection;
+        },
+        get doc() {
+            return doc;
+        },
+        get tr() {
+            selection = transaction.selection;
+            doc = transaction.doc;
+            storedMarks = transaction.storedMarks;
+            return transaction;
+        },
+    };
+}

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

@@ -0,0 +1,55 @@
+import { Attrs, MarkType, Node, NodeRange, NodeType, ResolvedPos } from 'prosemirror-model';
+import { Command, Transaction } from 'prosemirror-state';
+export { type Command } from 'prosemirror-state';
+export declare function wrapInList(listType: NodeType, attrs?: Attrs | null): Command;
+export declare function wrapRangeInList(tr: Transaction | null, range: NodeRange, listType: NodeType, attrs?: Attrs | null): boolean;
+export declare const deleteSelection: Command;
+export declare const joinBackward: Command;
+export declare const joinTextblockBackward: Command;
+export declare const joinTextblockForward: Command;
+export declare const selectNodeBackward: Command;
+export declare const joinForward: Command;
+export declare const selectNodeForward: Command;
+export declare const joinUp: Command;
+export declare const joinDown: Command;
+export declare const lift: Command;
+export declare const newlineInCode: Command;
+export declare const exitCode: Command;
+export declare const createParagraphNear: Command;
+export declare const liftEmptyBlock: Command;
+export declare function splitBlockAs(splitNode?: (node: Node, atEnd: boolean, $from: ResolvedPos) => {
+    type: NodeType;
+    attrs?: Attrs;
+} | null): Command;
+export declare const splitBlock: Command;
+export declare const splitBlockKeepMarks: Command;
+export declare const selectParentNode: Command;
+export declare const selectAll: Command;
+export declare const selectTextblockStart: Command;
+export declare const selectTextblockEnd: Command;
+export declare function wrapIn(nodeType: NodeType, attrs?: Attrs | null): Command;
+export declare function setBlockType(nodeType: NodeType, attrs?: Attrs | null): Command;
+export declare function toggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
+    removeWhenPresent?: boolean;
+    enterInlineAtoms?: boolean;
+    includeWhitespace?: boolean;
+}): Command;
+export declare function autoJoin(command: Command, isJoinable: ((before: Node, after: Node) => boolean) | readonly string[]): Command;
+export declare function chainCommands(...commands: readonly Command[]): Command;
+export declare function alternativeCommands(...commands: readonly Command[]): Command;
+export type CommandFactory = (...args: any[]) => Command;
+export interface Commands {
+    [name: string]: Command;
+}
+export interface CommandFactories {
+    [name: string]: CommandFactory;
+}
+export type CommandShortcuts = {
+    [name: string]: string;
+};
+export type ChainedCommands = {
+    [Item in keyof Commands]: (...args: unknown[]) => ChainedCommands;
+} & {
+    run: () => boolean;
+};
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/commands/mod.ts"],"names":[],"mappings":"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"}