@kerebron/extension-basic-editor 0.0.6 → 0.0.8

package/esm/extension-automerge/src/CursorPlugin.js

@@ -0,0 +1,114 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view'; // eslint-disable-line
+export const cursorPluginKey = new PluginKey('automerge-cursor');
+const getSelection = (state) => state.selection;
+export const createDecorations = (state, 
+// awareness,
+// awarenessFilter,
+createCursor, createSelection) => {
+    const decorations = [];
+    const user = { color: '#FF00' };
+    decorations.push(Decoration.inline(1, 2, createSelection(user), {
+        inclusiveEnd: true,
+        inclusiveStart: false,
+    }));
+    return DecorationSet.create(state.doc, decorations);
+};
+export const defaultSelectionBuilder = (user) => {
+    return {
+        style: `background-color: ${user.color}70`,
+        // assets: `border-left: 1px solid ${user.color}70`,
+        class: 'ProseMirror-yjs-selection',
+    };
+};
+export const defaultCursorBuilder = (user) => {
+    const cursor = document.createElement('span');
+    cursor.classList.add('ProseMirror-yjs-cursor');
+    cursor.setAttribute('style', `border-color: ${user.color}`);
+    const userDiv = document.createElement('div');
+    userDiv.setAttribute('style', `background-color: ${user.color}`);
+    userDiv.insertBefore(document.createTextNode(user.name), null);
+    const nonbreakingSpace1 = document.createTextNode('\u2060');
+    const nonbreakingSpace2 = document.createTextNode('\u2060');
+    cursor.insertBefore(nonbreakingSpace1, null);
+    cursor.insertBefore(userDiv, null);
+    cursor.insertBefore(nonbreakingSpace2, null);
+    return cursor;
+};
+const cursorBuilder = defaultCursorBuilder;
+const selectionBuilder = defaultSelectionBuilder;
+export class CursorPlugin extends Plugin {
+    constructor() {
+        super({
+            key: cursorPluginKey,
+            state: {
+                init(_, state) {
+                    return createDecorations(state, 
+                    // awareness,
+                    // awarenessStateFilter,
+                    cursorBuilder, selectionBuilder);
+                },
+                apply(tr, prevState, _oldState, newState) {
+                    // const ystate = ySyncPluginKey.getState(newState)
+                    // const yCursorState = tr.getMeta(yCursorPluginKey)
+                    // if (
+                    //     (ystate && ystate.isChangeOrigin) ||
+                    //     (yCursorState && yCursorState.awarenessUpdated)
+                    // ) {
+                    //     return createDecorations(
+                    //         newState,
+                    //         awareness,
+                    //         awarenessStateFilter,
+                    //         cursorBuilder,
+                    //         selectionBuilder
+                    //     )
+                    // }
+                    return prevState.map(tr.mapping, tr.doc);
+                },
+            },
+            props: {
+                decorations: (state) => {
+                    return cursorPluginKey.getState(state);
+                },
+            },
+            view: (view) => {
+                // const awarenessListener = () => {
+                //     if (view.docView) {
+                //         setMeta(view, yCursorPluginKey, { awarenessUpdated: true })
+                //     }
+                // }
+                const updateCursorInfo = () => {
+                    // @note We make implicit checks when checking for the cursor property
+                    // const current = awareness.getLocalState() || {}
+                    if (view.hasFocus()) {
+                        const selection = getSelection(view.state);
+                    }
+                };
+                // awareness.on('change', awarenessListener)
+                view.dom.addEventListener('focusin', updateCursorInfo);
+                view.dom.addEventListener('focusout', updateCursorInfo);
+                return {
+                    update: updateCursorInfo,
+                    destroy: () => {
+                        view.dom.removeEventListener('focusin', updateCursorInfo);
+                        view.dom.removeEventListener('focusout', updateCursorInfo);
+                        // awareness.off('change', awarenessListener)
+                        // awareness.setLocalStateField(cursorStateField, null)
+                    },
+                };
+            },
+        });
+        Object.defineProperty(this, "ignoreTr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onAutoMergeChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+}

package/esm/extension-automerge/src/ExtensionAutomerge.d.ts

@@ -0,0 +1,26 @@
+import { Schema, type SchemaSpec } from 'prosemirror-model';
+import { DocHandle, Repo } from '@automerge/automerge-repo';
+import { CoreEditor, Extension } from '../../editor/src/mod.js';
+import { NodeUnknown } from './NodeUnknown.js';
+import { MarkUnknown } from './MarkUnknown.js';
+import { NodeUnknownBlock } from './NodeUnknownBlock.js';
+import { SchemaAdapter } from './SchemaAdapter.js';
+import { SyncPlugin } from './SyncPlugin.js';
+export declare class ExtensionAutomerge extends Extension {
+    name: string;
+    requires: (NodeUnknown | MarkUnknown | NodeUnknownBlock)[];
+    schemaSpec: {};
+    repo: Repo;
+    editor: CoreEditor;
+    schemaAdapter: SchemaAdapter;
+    syncPlugin: SyncPlugin<{
+        text: string;
+    }>;
+    constructor(config: any);
+    setupSpec(actualSpec: SchemaSpec): void;
+    loadFromAutoMerge(docUrl: any): void;
+    setupDebug<T>(handle: DocHandle<T>): void;
+    notifyNewUrl(url: string): void;
+    getProseMirrorPlugins(editor: CoreEditor, schema: Schema): Plugin[];
+}
+//# sourceMappingURL=ExtensionAutomerge.d.ts.map

package/esm/extension-automerge/src/ExtensionAutomerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionAutomerge.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/ExtensionAutomerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG5D,OAAO,EACL,SAAS,EAET,IAAI,EACL,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAwB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAM7C,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,IAAI,SAAe;IAEnB,QAAQ,mDAAkE;IAE1E,UAAU,KAAM;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;IACnB,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;gBAE7B,MAAM,KAAA;IAUT,SAAS,CAAC,UAAU,EAAE,UAAU;IAKzC,iBAAiB,CAAC,MAAM,KAAA;IAWxB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAmBlC,YAAY,CAAC,GAAG,EAAE,MAAM;IAUf,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;CAyC7E"}

package/esm/extension-automerge/src/ExtensionAutomerge.js

@@ -0,0 +1,136 @@
+import { next as automerge } from '@automerge/automerge/slim';
+import { isValidAutomergeUrl, Repo, } from '@automerge/automerge-repo';
+import { Extension } from '../../editor/src/mod.js';
+import { NodeUnknown } from './NodeUnknown.js';
+import { MarkUnknown } from './MarkUnknown.js';
+import { NodeUnknownBlock } from './NodeUnknownBlock.js';
+import { addAmgNodeStateAttrs, SchemaAdapter } from './SchemaAdapter.js';
+import { SyncPlugin } from './SyncPlugin.js';
+import { CursorPlugin } from './CursorPlugin.js';
+import { pmDocToAmHandle } from './loader.js';
+const pathToTextField = ['text'];
+export class ExtensionAutomerge extends Extension {
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'automerge'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [new NodeUnknown(), new MarkUnknown(), new NodeUnknownBlock()]
+        });
+        Object.defineProperty(this, "schemaSpec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "repo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schemaAdapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "syncPlugin", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.repo = new Repo({
+            storage: this.config.storage,
+            // storage: new IndexedDBStorageAdapter("automerge"),
+            network: [this.config.networkAdapter],
+        });
+    }
+    setupSpec(actualSpec) {
+        addAmgNodeStateAttrs(actualSpec.nodes);
+        this.schemaSpec = actualSpec;
+    }
+    loadFromAutoMerge(docUrl) {
+        let handle;
+        if (docUrl && isValidAutomergeUrl(docUrl)) {
+            handle = this.repo.find(docUrl);
+            this.syncPlugin.changeHandle(handle);
+            //pmDocToAmHandle(this.schemaAdapter, handle, pmDoc);
+            this.setupDebug(handle, this.editor);
+            this.notifyNewUrl(handle.url);
+        }
+    }
+    setupDebug(handle) {
+        handle.on('change', (event) => {
+            if (!handle.isReady()) {
+                return;
+            }
+            const doc = handle.docSync();
+            if (doc) {
+                const event = new CustomEvent('automerge:change', {
+                    detail: {
+                        editor: this.editor,
+                        getSpans: () => automerge.spans(doc, pathToTextField),
+                        getMarks: () => automerge.marks(doc, pathToTextField),
+                    },
+                });
+                this.editor.dispatchEvent(event);
+            }
+        });
+    }
+    notifyNewUrl(url) {
+        const event = new CustomEvent('automerge:url', {
+            detail: {
+                editor: this.editor,
+                url,
+            },
+        });
+        this.editor.dispatchEvent(event);
+    }
+    getProseMirrorPlugins(editor, schema) {
+        this.editor = editor;
+        const schemaAdapter = new SchemaAdapter(schema);
+        this.schemaAdapter = schemaAdapter;
+        let handle;
+        handle = this.repo.create({ text: '' });
+        const syncPlugin = new SyncPlugin(schemaAdapter, pathToTextField, handle);
+        this.syncPlugin = syncPlugin;
+        editor.addEventListener('doc:loaded', (event) => {
+            const pmDoc = event.detail.doc;
+            // const handle = this.repo.create({ text: '' });
+            handle.whenReady()
+                .then(() => {
+                syncPlugin.changeHandle(handle);
+                pmDocToAmHandle(schemaAdapter, handle, pmDoc);
+                this.setupDebug(handle);
+            });
+        });
+        handle.whenReady()
+            .then(() => {
+            this.notifyNewUrl(handle.url);
+            const doc = handle.docSync();
+            if (!doc) {
+                throw new Error('cannot initialize ProseMirror document when handle is not ready');
+            }
+            this.setupDebug(handle);
+        });
+        return [
+            syncPlugin,
+            new CursorPlugin(),
+        ];
+    }
+}

package/esm/extension-automerge/src/MarkUnknown.d.ts

@@ -0,0 +1,8 @@
+import { MarkSpec } from 'prosemirror-model';
+import { Mark } from '../../editor/src/mod.js';
+export declare class MarkUnknown extends Mark {
+    name: string;
+    requires: string[];
+    getMarkSpec(): MarkSpec;
+}
+//# sourceMappingURL=MarkUnknown.d.ts.map

package/esm/extension-automerge/src/MarkUnknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkUnknown.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/MarkUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,qBAAa,WAAY,SAAQ,IAAI;IAC1B,IAAI,SAAiB;IAC9B,QAAQ,WAAW;IAEnB,WAAW,IAAI,QAAQ;CAQxB"}

package/esm/extension-automerge/src/MarkUnknown.js

@@ -0,0 +1,26 @@
+import { Mark } from '../../editor/src/mod.js';
+export class MarkUnknown extends Mark {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'unknownMark'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+    }
+    getMarkSpec() {
+        return {
+            attrs: { unknownMarks: { default: null } },
+            toDOM() {
+                return ['span', { 'data-unknown-mark': true }];
+            },
+        };
+    }
+}

package/esm/extension-automerge/src/NodeUnknown.d.ts

@@ -0,0 +1,8 @@
+import { NodeSpec } from 'prosemirror-model';
+import { Node } from '../../editor/src/mod.js';
+export declare class NodeUnknown extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+}
+//# sourceMappingURL=NodeUnknown.d.ts.map

package/esm/extension-automerge/src/NodeUnknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeUnknown.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/NodeUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,qBAAa,WAAY,SAAQ,IAAI;IAC1B,IAAI,SAAiB;IAC9B,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;CAUjC"}

package/esm/extension-automerge/src/NodeUnknown.js

@@ -0,0 +1,28 @@
+import { Node } from '../../editor/src/mod.js';
+export class NodeUnknown extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'unknownLeaf'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+    }
+    getNodeSpec() {
+        return {
+            inline: true,
+            attrs: { isAmgBlock: { default: true }, unknownBlock: { default: null } },
+            group: 'inline',
+            toDOM() {
+                return document.createTextNode('u{fffc}');
+            },
+        };
+    }
+}

package/esm/extension-automerge/src/NodeUnknownBlock.d.ts

@@ -0,0 +1,11 @@
+import { NodeSpec } from 'prosemirror-model';
+import { Node } from '../../editor/src/mod.js';
+export declare class NodeUnknownBlock extends Node {
+    name: string;
+    requires: string[];
+    automerge: {
+        unknownBlock: boolean;
+    };
+    getNodeSpec(): NodeSpec;
+}
+//# sourceMappingURL=NodeUnknownBlock.d.ts.map

package/esm/extension-automerge/src/NodeUnknownBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeUnknownBlock.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/NodeUnknownBlock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,qBAAa,gBAAiB,SAAQ,IAAI;IAC/B,IAAI,SAAkB;IAC/B,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEO,WAAW,IAAI,QAAQ;CAUjC"}

package/esm/extension-automerge/src/NodeUnknownBlock.js

@@ -0,0 +1,36 @@
+import { Node } from '../../editor/src/mod.js';
+export class NodeUnknownBlock extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'unknownBlock'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                unknownBlock: true,
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            group: 'block',
+            content: 'block+',
+            parseDOM: [{ tag: 'div', attrs: { 'data-unknown-block': 'true' } }],
+            toDOM() {
+                return ['div', { 'data-unknown-block': 'true' }, 0];
+            },
+        };
+    }
+}

package/esm/extension-automerge/src/SchemaAdapter.d.ts

@@ -0,0 +1,70 @@
+import { Attrs, Mark, MarkSpec, MarkType, Node, NodeSpec, NodeType, type Schema } from 'prosemirror-model';
+import { next as automerge } from '@automerge/automerge/slim';
+import { BlockMarker } from './types.js';
+export interface MappedSchemaSpec {
+    nodes: {
+        [key: string]: MappedNodeSpec;
+    };
+    marks?: {
+        [key: string]: MappedMarkSpec;
+    };
+}
+export type MappedNodeSpec = NodeSpec & {
+    automerge?: {
+        unknownBlock?: boolean;
+        block?: BlockMappingSpec;
+        isEmbed?: boolean;
+        attrParsers?: {
+            fromProsemirror: (node: Node) => {
+                [key: string]: automerge.MaterializeValue;
+            };
+            fromAutomerge: (block: BlockMarker) => Attrs;
+        };
+    };
+};
+export type BlockMappingSpec = string;
+export type MappedMarkSpec = MarkSpec & {
+    automerge?: {
+        markName: string;
+        parsers?: {
+            fromAutomerge: (value: automerge.MarkValue) => Attrs;
+            fromProsemirror: (mark: Mark) => automerge.MarkValue;
+        };
+    };
+};
+export type MarkMapping = {
+    automergeMarkName: string;
+    prosemirrorMark: MarkType;
+    parsers: {
+        fromAutomerge: (value: automerge.MarkValue) => Attrs;
+        fromProsemirror: (mark: Mark) => automerge.MarkValue;
+    };
+};
+export type NodeMapping = {
+    blockName: string;
+    content: NodeType;
+    attrParsers?: {
+        fromProsemirror: (node: Node) => {
+            [key: string]: automerge.MaterializeValue;
+        };
+        fromAutomerge: (block: BlockMarker) => Attrs;
+    };
+    isEmbed?: boolean;
+};
+export declare class SchemaAdapter {
+    nodeMappings: NodeMapping[];
+    markMappings: MarkMapping[];
+    unknownBlock: NodeType;
+    unknownLeaf: NodeType;
+    unknownMark: MarkType;
+    schema: Schema;
+    constructor(schema: Schema);
+}
+export declare function addAmgNodeStateAttrs(nodes: {
+    [key: string]: MappedNodeSpec;
+}): {
+    [key: string]: MappedNodeSpec;
+};
+export declare function amMarksFromPmMarks(adapter: SchemaAdapter, marks: readonly Mark[]): automerge.MarkSet;
+export declare function pmMarksFromAmMarks(adapter: SchemaAdapter, amMarks: automerge.MarkSet): Mark[];
+//# sourceMappingURL=SchemaAdapter.d.ts.map

package/esm/extension-automerge/src/SchemaAdapter.d.ts.map

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