@kerebron/extension-basic-editor 0.1.2 → 0.1.3

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

@@ -1,54 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,464 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}