@kerebron/extension-basic-editor 0.0.6 → 0.0.8

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

@@ -0,0 +1,54 @@
+import { next as automerge } from '@automerge/automerge';
+import { EditorState } from 'prosemirror-state';
+import { pmToAm } from './pmToAm.js';
+function removeMarksRecursively(schema, node) {
+    if (node.isText) {
+        return schema.text(node.text);
+    }
+    else {
+        const newChildren = [];
+        node.content.forEach((child) => {
+            newChildren.push(removeMarksRecursively(schema, child));
+        });
+        return node.copy(node.type.create(null, newChildren).content);
+    }
+}
+function replaceDocWithoutMarks(oldState, newDoc) {
+    const { tr } = oldState;
+    const cleanDoc = removeMarksRecursively(oldState.schema, newDoc);
+    tr.replaceWith(0, oldState.doc.content.size, cleanDoc.content);
+    return tr;
+}
+function addMarksToTransaction(doc, tr) {
+    doc.descendants((node, pos) => {
+        if (node.isText) {
+            for (const mark of node.marks) {
+                tr.addMark(pos, pos + node.nodeSize, mark);
+            }
+        }
+    });
+}
+export function createEmptyDocFromExisting(doc) {
+    return doc.type.createAndFill();
+}
+export function pmDocToAm(basicSchemaAdapter, amDoc, docToLoad, pathToTextField = ['text']) {
+    const spans = automerge.spans(amDoc, pathToTextField);
+    const emptyDoc = createEmptyDocFromExisting(docToLoad);
+    const state = EditorState.create({ doc: emptyDoc });
+    const tr = replaceDocWithoutMarks(state, docToLoad);
+    addMarksToTransaction(docToLoad, tr);
+    return automerge.change(amDoc, (d) => {
+        pmToAm(basicSchemaAdapter, spans, tr.steps, d, tr.docs[0], pathToTextField);
+    });
+}
+export function pmDocToAmHandle(basicSchemaAdapter, handle, docToLoad, pathToTextField = ['text']) {
+    const amDoc = handle.docSync();
+    const spans = automerge.spans(amDoc, pathToTextField);
+    const emptyDoc = createEmptyDocFromExisting(docToLoad);
+    const state = EditorState.create({ doc: emptyDoc });
+    const tr = replaceDocWithoutMarks(state, docToLoad);
+    addMarksToTransaction(docToLoad, tr);
+    handle.change((d) => {
+        pmToAm(basicSchemaAdapter, spans, tr.steps, d, tr.docs[0], pathToTextField);
+    });
+}

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

@@ -0,0 +1,9 @@
+import { next as automerge } from '@automerge/automerge/slim';
+export declare function patchSpans(atPath: automerge.Prop[], spans: automerge.Span[], patch: automerge.Patch): void;
+export declare function applyBlockPatch(parentPath: automerge.Prop[], patch: automerge.Patch, block: {
+    [key: string]: automerge.MaterializeValue;
+}): void;
+export declare function findBlockAtCharIdx(spans: automerge.Span[], charIdx: number): {
+    [key: string]: automerge.MaterializeValue;
+} | null;
+//# sourceMappingURL=maintainSpans.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"maintainSpans.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/maintainSpans.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAG9D,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,EACxB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,KAAK,EAAE,SAAS,CAAC,KAAK,QA+BvB;AA+TD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,SAAS,CAAC,IAAI,EAAE,EAC5B,KAAK,EAAE,SAAS,CAAC,KAAK,EACtB,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,gBAAgB,CAAA;CAAE,QAqCrD;AAqFD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,OAAO,EAAE,MAAM,GACd;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,gBAAgB,CAAA;CAAE,GAAG,IAAI,CAatD"}

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

@@ -0,0 +1,464 @@
+import { next as automerge } from '@automerge/automerge/slim';
+import { isArrayEqual, isPrefixOfArray } from './utils.js';
+export function patchSpans(atPath, spans, patch) {
+    if (isArrayEqual(atPath, patch.path)) {
+        if (patch.action === 'mark') {
+            for (const mark of patch.marks) {
+                markSpans(spans, mark);
+            }
+        }
+    }
+    else if (isPrefixOfArray(atPath, patch.path)) {
+        if (patch.path.length === atPath.length + 1) {
+            // This is either an insert or delete of a block
+            if (patch.action === 'insert') {
+                insertBlock(spans, patch);
+            }
+            else if (patch.action === 'del') {
+                deleteSpans(spans, patch);
+            }
+            else if (patch.action === 'splice') {
+                spliceSpans(spans, patch);
+            }
+        }
+        else {
+            const index = patch.path[atPath.length];
+            if (typeof index !== 'number') {
+                console.error(`Invalid path: ${patch.path}`);
+                throw new Error('Invalid path: expected number when patching spans');
+            }
+            const block = findBlockAtCharIdx(spans, index);
+            if (block == null) {
+                throw new Error('Invalid path: unable to find block at index');
+            }
+            applyBlockPatch(atPath, patch, block);
+        }
+    }
+}
+function spliceSpans(spans, patch) {
+    let idx = 0;
+    const patchIndex = patch.path[patch.path.length - 1];
+    if (typeof patchIndex !== 'number') {
+        return;
+    }
+    let spanIdx = 0;
+    while (spanIdx < spans.length) {
+        const span = spans[spanIdx];
+        // Scenarios
+        // 1. We are inserting into the range of an existing text span
+        //   * With the same marks
+        //   * With different marks
+        // 3. We are inserting at the end of an existing text span
+        //   * With the same marks
+        //   * With different marks
+        // 4. We are inserting into the range of a block
+        // 5. We are inserting at the end of a block
+        if (span.type === 'text') {
+            if (idx <= patchIndex && idx + span.value.length > patchIndex) {
+                const offset = patchIndex - idx;
+                const before = span.value.slice(0, offset);
+                const after = span.value.slice(offset);
+                if (marksEqual(span.marks, patch.marks)) {
+                    span.value = before + patch.value + after;
+                }
+                else {
+                    const newSpans = [];
+                    const prevSpan = spans[spanIdx - 1];
+                    if (before.length === 0 &&
+                        prevSpan &&
+                        prevSpan.type === 'text' &&
+                        marksEqual(prevSpan.marks, patch.marks)) {
+                        prevSpan.value += patch.value;
+                    }
+                    else {
+                        if (before.length > 0) {
+                            newSpans.push(makeTextSpan({
+                                value: before,
+                                marks: span.marks,
+                            }));
+                        }
+                        newSpans.push(makeTextSpan({
+                            value: patch.value,
+                            marks: patch.marks,
+                        }));
+                    }
+                    if (after.length > 0) {
+                        newSpans.push(makeTextSpan({
+                            value: after,
+                            marks: span.marks,
+                        }));
+                    }
+                    spans.splice(spanIdx, 1, ...newSpans);
+                }
+                return;
+            }
+            else {
+                idx += span.value.length;
+                spanIdx += 1;
+            }
+        }
+        else {
+            if (idx === patchIndex) {
+                const prevSpan = spans[spanIdx - 1];
+                if (prevSpan != null &&
+                    prevSpan.type === 'text' &&
+                    marksEqual(prevSpan.marks, patch.marks)) {
+                    // if the block marker is after a text span with the same marks,
+                    // add this text to that span
+                    prevSpan.value += patch.value;
+                }
+                else {
+                    // otherwise insert a text span before the block
+                    const newSpan = {
+                        type: 'text',
+                        value: patch.value,
+                    };
+                    if (patch.marks != null) {
+                        newSpan.marks = patch.marks;
+                    }
+                    spans.splice(spanIdx, 0, newSpan);
+                }
+                return;
+            }
+            idx += 1;
+            spanIdx += 1;
+        }
+    }
+    if (idx === patchIndex) {
+        //we're inserting at the end
+        const lastSpan = spans[spans.length - 1];
+        if (lastSpan &&
+            lastSpan.type === 'text' &&
+            marksEqual(lastSpan.marks || {}, patch.marks || {})) {
+            lastSpan.value += patch.value;
+        }
+        else {
+            const newSpan = {
+                type: 'text',
+                value: patch.value,
+            };
+            if (patch.marks != null) {
+                newSpan.marks = patch.marks;
+            }
+            spans.push(newSpan);
+        }
+    }
+}
+function markSpans(spans, patch) {
+    let textPos = 0;
+    let i = 0;
+    while (i < spans.length) {
+        const span = spans[i];
+        if (span.type === 'text') {
+            const spanStart = textPos;
+            const spanEnd = textPos + span.value.length;
+            if (spanStart < patch.end && spanEnd > patch.start) {
+                const startOffset = Math.max(0, patch.start - spanStart);
+                const endOffset = Math.min(span.value.length, patch.end - spanStart);
+                if (startOffset > 0) {
+                    spans.splice(i, 1, makeTextSpan({
+                        value: span.value.slice(0, startOffset),
+                        marks: span.marks,
+                    }), makeTextSpan({
+                        value: span.value.slice(startOffset, endOffset),
+                        marks: {
+                            ...span.marks,
+                            [patch.name]: patch.value,
+                        },
+                    }));
+                    i++;
+                }
+                else {
+                    spans[i] = makeTextSpan({
+                        value: span.value.slice(0, endOffset),
+                        marks: {
+                            ...span.marks,
+                            [patch.name]: patch.value,
+                        },
+                    });
+                }
+                if (endOffset < span.value.length) {
+                    spans.splice(i + 1, 0, makeTextSpan({
+                        value: span.value.slice(endOffset),
+                        marks: span.marks,
+                    }));
+                }
+                // Merge with previous span if marks are the same
+                const prevSpan = spans[i - 1];
+                let thisSpan = spans[i];
+                if (i > 0 &&
+                    prevSpan.type === 'text' &&
+                    thisSpan.type === 'text' &&
+                    marksEqual(prevSpan.marks, thisSpan.marks)) {
+                    prevSpan.value += thisSpan.value;
+                    spans.splice(i, 1);
+                }
+                else {
+                    i++;
+                }
+                // Merge with next span if marks are the same
+                const nextSpan = spans[i + 1];
+                thisSpan = spans[i];
+                if (i < spans.length - 1 &&
+                    nextSpan.type === 'text' &&
+                    thisSpan.type === 'text' &&
+                    marksEqual(nextSpan.marks, thisSpan.marks)) {
+                    thisSpan.value += nextSpan.value;
+                    spans.splice(i + 1, 1);
+                }
+            }
+            else {
+                i++;
+            }
+            textPos += span.value.length;
+        }
+        else {
+            i++;
+            textPos += 1;
+        }
+    }
+}
+function deleteSpans(spans, patch) {
+    const start = patch.path[patch.path.length - 1];
+    if (typeof start !== 'number') {
+        throw new Error('Invalid path: expected number when deleting spans');
+    }
+    const end = start + (patch.length || 1);
+    let deleteCount = 0;
+    // This is always the offset of the start of spans[i] in the _current_ spans
+    // (i.e. not the original spans)
+    let textPos = 0;
+    let i = 0;
+    // Returns the amount to rewind `textPos` by
+    function mergeSpans(index) {
+        const prevSpan = spans[index - 1];
+        const thisSpan = spans[index];
+        if (prevSpan &&
+            prevSpan.type === 'text' &&
+            thisSpan &&
+            thisSpan.type === 'text' &&
+            marksEqual(prevSpan.marks, thisSpan.marks)) {
+            const rewind = prevSpan.value.length;
+            prevSpan.value += thisSpan.value;
+            spans.splice(index, 1);
+            return rewind;
+        }
+        return;
+    }
+    while (i < spans.length && deleteCount < end - start) {
+        const span = spans[i];
+        const adjustedEnd = end - deleteCount;
+        if (span.type === 'text') {
+            const spanStart = textPos;
+            const spanEnd = textPos + span.value.length;
+            if (spanStart >= start && spanEnd <= adjustedEnd) {
+                // Span is fully within the deletion range, remove it
+                spans.splice(i, 1);
+                deleteCount += span.value.length;
+                mergeSpans(i);
+            }
+            else if (spanStart < adjustedEnd && spanEnd > start) {
+                // Span partially overlaps with the deletion range
+                const startOffset = Math.max(0, start - spanStart);
+                const endOffset = Math.min(span.value.length, adjustedEnd - spanStart);
+                if (startOffset > 0 && endOffset < span.value.length) {
+                    // Split the span into two parts
+                    spans.splice(i, 1, makeTextSpan({
+                        value: span.value.slice(0, startOffset),
+                        marks: span.marks,
+                    }), makeTextSpan({
+                        value: span.value.slice(endOffset),
+                        marks: span.marks,
+                    }));
+                    i++;
+                    (textPos += startOffset), (deleteCount += endOffset - startOffset);
+                }
+                else if (startOffset > 0) {
+                    deleteCount += span.value.length - startOffset;
+                    // Truncate the end of the span
+                    span.value = span.value.slice(0, startOffset);
+                }
+                else if (endOffset < span.value.length) {
+                    deleteCount += endOffset;
+                    // Truncate the start of the span
+                    span.value = span.value.slice(endOffset);
+                }
+                const rewind = mergeSpans(i);
+                if (rewind) {
+                    textPos -= rewind;
+                }
+                else {
+                    i++;
+                    textPos += span.value.length;
+                }
+            }
+            else {
+                textPos += span.value.length;
+                i++;
+            }
+        }
+        else if (span.type === 'block') {
+            if (textPos >= start && textPos < adjustedEnd) {
+                // Block is within the deletion range, remove it
+                spans.splice(i, 1);
+                deleteCount += 1;
+                const rewind = mergeSpans(i);
+                if (rewind) {
+                    i--;
+                    textPos -= rewind;
+                }
+            }
+            else {
+                textPos++;
+                i++;
+            }
+        }
+    }
+}
+export function applyBlockPatch(parentPath, patch, block) {
+    const pathInBlock = patch.path.slice(parentPath.length + 1);
+    if (patch.action === 'put') {
+        const target = resolveTarget(block, pathInBlock.slice(0, -1));
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        // deno-lint-ignore no-cond-assign
+        const key = patch.path[patch.path.length - 1];
+        target[key] = copyValue(patch.value);
+    }
+    else if (patch.action === 'insert') {
+        const target = resolveTarget(block, pathInBlock.slice(0, -2));
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const insertAt = pathInBlock.pop();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const prop = pathInBlock.pop();
+        const arr = target[prop];
+        if (!Array.isArray(arr)) {
+            throw new Error('Invalid path: expected array when inserting');
+        }
+        arr.splice(insertAt, 0, ...copyValues(patch.values));
+    }
+    else if (patch.action === 'splice') {
+        const target = resolveTarget(block, pathInBlock.slice(0, -2));
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const insertAt = pathInBlock.pop();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const prop = pathInBlock.pop();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const before = target[prop];
+        const after = before.slice(0, insertAt) + patch.value +
+            before.slice(insertAt);
+        target[prop] = after;
+    }
+    else if (patch.action === 'del') {
+        const target = resolveTarget(block, pathInBlock.slice(0, -1));
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const key = patch.path[patch.path.length - 1];
+        delete target[key];
+    }
+}
+function copyValues(vals) {
+    // Copy RawString by value because otherwise instanceof fails
+    return vals.map((val) => copyValue(val));
+}
+function copyValue(val) {
+    // Copy RawString by value because otherwise instanceof fails
+    if (val instanceof automerge.RawString) {
+        return new automerge.RawString(val.toString());
+    }
+    return structuredClone(val);
+}
+function resolveTarget(block, path) {
+    let target = block;
+    for (const pathElem of path) {
+        if (typeof target !== 'object') {
+            throw new Error('Invalid path: expected object when resolving target');
+        }
+        target = target[pathElem];
+    }
+    return target;
+}
+function insertBlock(spans, patch) {
+    let idx = 0;
+    let spanIdx = 0;
+    const patchIndex = patch.path[patch.path.length - 1];
+    if (typeof patchIndex !== 'number') {
+        throw new Error(`Invalid patch path, expected a number got ", ${patch.path[patch.path.length - 1]}`);
+    }
+    const newBlocks = [];
+    for (const val of patch.values) {
+        if (!val || typeof val !== 'object') {
+            throw new Error('Invalid patch: expected object when inserting');
+        }
+        if (!(Object.keys(val).length === 0)) {
+            throw new Error('Invalid patch: unexpected nonempty object when inserting');
+        }
+        newBlocks.push({
+            type: 'block',
+            value: {},
+        });
+    }
+    while (idx < patchIndex && spanIdx < spans.length) {
+        const span = spans[spanIdx];
+        if (span.type == 'text') {
+            if (span.value.length + idx > patchIndex) {
+                const offset = patchIndex - idx;
+                const left = span.value.slice(0, offset);
+                const right = span.value.slice(offset);
+                span.value = left;
+                spans.splice(spanIdx + 1, 0, ...newBlocks);
+                spans.splice(spanIdx + newBlocks.length + 1, 0, {
+                    type: 'text',
+                    value: right,
+                });
+                return;
+            }
+            idx += span.value.length;
+        }
+        else {
+            idx += 1;
+        }
+        spanIdx += 1;
+    }
+    spans.splice(spanIdx, 0, ...newBlocks);
+}
+export function findBlockAtCharIdx(spans, charIdx) {
+    let idx = 0;
+    for (const span of spans) {
+        if (span.type === 'block') {
+            if (idx === charIdx) {
+                return span.value;
+            }
+            idx += 1;
+        }
+        else {
+            idx += span.value.length;
+        }
+    }
+    return null;
+}
+function marksEqual(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+marks1, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+marks2) {
+    if (marks1 === marks2) {
+        return true;
+    }
+    if (!marks1 ||
+        !marks2 ||
+        Object.keys(marks1).length !== Object.keys(marks2).length) {
+        return false;
+    }
+    for (const key in marks1) {
+        if (marks1[key] !== marks2[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+function makeTextSpan({ value, marks, }) {
+    const result = { type: 'text', value };
+    if (marks != null) {
+        result.marks = marks;
+    }
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import { Step } from 'prosemirror-transform';
+import { Node } from 'prosemirror-model';
+import { next as automerge, Prop } from '@automerge/automerge/slim';
+import { SchemaAdapter } from './SchemaAdapter.js';
+export declare function pmToAm(adapter: SchemaAdapter, spans: automerge.Span[], steps: Step[], doc: any, pmDoc: Node, path: Prop[]): void;
+//# sourceMappingURL=pmToAm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pmToAm.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/pmToAm.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,IAAI,EACL,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAkB,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAsB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEvE,wBAAgB,MAAM,CACpB,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,KAAK,EAAE,IAAI,EAAE,EAEb,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,IAAI,EACX,IAAI,EAAE,IAAI,EAAE,QA4Bb"}