@kerebron/editor 0.4.27 → 0.4.28

package/esm/Node.js

@@ -0,0 +1,36 @@
+export class Node {
+    config;
+    type = 'node';
+    name = 'node';
+    editor;
+    attributes = {};
+    constructor(config = {}) {
+        this.config = config;
+    }
+    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/commands/CommandManager.d.ts

@@ -0,0 +1,24 @@
+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;
+    private overwriteCommandFactory;
+    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/commands/CommandManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandManager.d.ts","sourceRoot":"","sources":["../../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;IAWjB,OAAO,CAAC,uBAAuB;IAqC/B,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/commands/CommandManager.js

@@ -0,0 +1,100 @@
+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 {
+    editor;
+    commandFactories = {};
+    run = {};
+    debug = true;
+    constructor(editor) {
+        this.editor = editor;
+        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;
+            }
+            this.overwriteCommandFactory(extName, key, commandFactory);
+        }
+    }
+    overwriteCommandFactory(extName, name, commandFactory) {
+        if (this.debug) {
+            const wrappedFactory = (...args) => {
+                const realCommand = commandFactory(...args);
+                const command = (state, dispatch, view) => {
+                    if (dispatch) {
+                        console.debug(`Command: ${extName}.${name}`);
+                    }
+                    return realCommand(state, dispatch, view);
+                };
+                return command;
+            };
+            this.commandFactories[name] = wrappedFactory;
+        }
+        else {
+            this.commandFactories[name] = commandFactory;
+        }
+        this.run[name] = (...args) => {
+            const factory = this.commandFactories[name];
+            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/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/commands/baseCommandFactories.d.ts.map

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