document-model 2.20.0 → 2.21.1

package/dist/test/document/undo-redo.test.js

@@ -0,0 +1,376 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { noop, redo, undo } from "../../src/document/actions/creators.js";
+import { processUndoRedo } from "../../src/document/reducer.js";
+import { baseCreateDocument, baseCreateExtendedState, } from "../../src/document/utils/base.js";
+import { countReducer, increment, } from "../helpers.js";
+describe("UNDO/REDO", () => {
+    let document;
+    beforeEach(() => {
+        const initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        document = baseCreateDocument(initialState);
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+    });
+    describe("processUndoRedo -> UNDO", () => {
+        it("should return a NOOP action when an UNDO action is dispatched", () => {
+            const skip = 0;
+            const undoAction = undo();
+            const result = processUndoRedo(document, undoAction, skip);
+            expect(result.action.type).toBe("NOOP");
+        });
+        it("should return skip = undo value if there's no skip value passed to the reducer", () => {
+            const skip = 0;
+            const undoAction = undo();
+            const result = processUndoRedo(document, undoAction, skip);
+            expect(result.skip).toBe(1);
+            expect(result.action.type).toBe("NOOP");
+        });
+        it("should return skip = undo value + previous NOOP skip value, when latest action is NOOP with skip > 0", () => {
+            const skip = 0;
+            const undoAction = undo();
+            document = countReducer(document, noop(), undefined, {
+                skip: 3,
+                ignoreSkipOperations: true,
+            });
+            const result = processUndoRedo(document, undoAction, skip);
+            expect(result.skip).toBe(4);
+            expect(result.action.type).toBe("NOOP");
+        });
+        it("should NOT remove latest operation if !== NOOP", () => {
+            const skip = 0;
+            const undoAction = undo();
+            const result = processUndoRedo(document, undoAction, skip);
+            expect(result.skip).toBe(1);
+            expect(result.document.operations.global.length).toBe(5);
+            expect(result.document.operations.global[4].type).toBe("INCREMENT");
+        });
+        it("should NOT remove latest operation if is a NOOP with skip = 0", () => {
+            const skip = 0;
+            const undoAction = undo();
+            document = countReducer(document, noop(), undefined, {
+                skip: 0,
+                ignoreSkipOperations: true,
+            });
+            const result = processUndoRedo(document, undoAction, skip);
+            expect(result.skip).toBe(1);
+            expect(result.document.operations.global.length).toBe(6);
+            expect(result.document.operations.global[5].type).toBe("NOOP");
+        });
+        it("should throw an error if you try to undone more operations than the ones available", () => {
+            const initialState = baseCreateExtendedState({
+                documentType: "powerhouse/counter",
+                state: { global: { count: 0 }, local: { name: "" } },
+            });
+            document = baseCreateDocument(initialState);
+            const skip = 0;
+            const undoAction = undo();
+            const throwErrorFunc = () => processUndoRedo(document, undoAction, skip);
+            expect(throwErrorFunc).toThrow("Cannot undo: you can't undo more operations than the ones in the scope history");
+        });
+    });
+    describe("processUndoRedo -> REDO", () => {
+        it("should throw an error when there's no operation to redo in the clipboard", () => {
+            const initialState = baseCreateExtendedState({
+                documentType: "powerhouse/counter",
+                state: { global: { count: 0 }, local: { name: "" } },
+            });
+            document = baseCreateDocument(initialState);
+            const skip = 0;
+            const redoAction = redo();
+            const throwErrorFunc = () => processUndoRedo(document, redoAction, skip);
+            expect(throwErrorFunc).toThrow("Cannot redo: no operations in the clipboard");
+        });
+        it("should throw an error if you try to redo more than 1 operation", () => {
+            const skip = 0;
+            const redoAction = redo(2);
+            const throwErrorFunc = () => processUndoRedo(document, redoAction, skip);
+            expect(throwErrorFunc).toThrow("Cannot redo: you can only redo one operation at a time");
+        });
+        it("should throw an error if you try to redo with an skip value", () => {
+            const skip = 1;
+            const redoAction = redo(1);
+            const throwErrorFunc = () => processUndoRedo(document, redoAction, skip);
+            expect(throwErrorFunc).toThrow("Cannot redo: skip value from reducer cannot be used with REDO action");
+        });
+        it("should throw an error if there's no operations for the scope in the clipboard", () => {
+            const skip = 0;
+            const redoAction = redo(1, "local");
+            document = countReducer(document, undo(1));
+            const throwErrorFunc = () => processUndoRedo(document, redoAction, skip);
+            expect(throwErrorFunc).toThrow('Cannot redo: no operations in clipboard for scope "local"');
+        });
+        it("should transform REDO action into the latest valid action stored in the clipboard", () => {
+            const skip = 0;
+            const redoAction = redo(1);
+            document = countReducer(document, undo(1));
+            const result = processUndoRedo(document, redoAction, skip);
+            expect(result.action.type).toBe("INCREMENT");
+            expect(result.action.scope).toBe("global");
+            expect(result.action.input).toBe(undefined);
+        });
+        it("should remove the latest valid action from the clipboard", () => {
+            const skip = 0;
+            const redoAction = redo(1);
+            document = countReducer(document, undo(1));
+            expect(document.clipboard.length).toBe(1);
+            const result = processUndoRedo(document, redoAction, skip);
+            expect(result.document.clipboard.length).toBe(0);
+        });
+    });
+    describe("UNDO", () => {
+        it("should undo operations", () => {
+            document = countReducer(document, undo(1));
+            expect(document.revision.global).toBe(6);
+            expect(document.state.global.count).toBe(4);
+            expect(document.clipboard.length).toBe(1);
+            expect(document.clipboard[0].type).toBe("INCREMENT");
+            expect(document.clipboard[0].index).toBe(4);
+            expect(document.operations.global.length).toBe(5);
+            expect(document.operations.global[4]).toMatchObject({
+                type: "NOOP",
+                index: 5,
+                skip: 1,
+            });
+            expect(document.operations.global[3]).toMatchObject({
+                type: "INCREMENT",
+                index: 3,
+                skip: 0,
+            });
+            expect(document.operations.global[2]).toMatchObject({
+                type: "INCREMENT",
+                index: 2,
+                skip: 0,
+            });
+        });
+        it("should increase skip value of a previous undo Operation", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            expect(document.revision.global).toBe(6);
+            expect(document.state.global.count).toBe(2);
+            expect(document.clipboard.length).toBe(3);
+            expect(document.clipboard[0].type).toBe("INCREMENT");
+            expect(document.clipboard[0].index).toBe(4);
+            expect(document.clipboard[1].type).toBe("INCREMENT");
+            expect(document.clipboard[1].index).toBe(3);
+            expect(document.clipboard[2].type).toBe("INCREMENT");
+            expect(document.clipboard[2].index).toBe(2);
+            expect(document.operations.global.length).toBe(3);
+            expect(document.operations.global[2]).toMatchObject({
+                type: "NOOP",
+                index: 5,
+                skip: 3,
+            });
+            expect(document.operations.global[1]).toMatchObject({
+                type: "INCREMENT",
+                index: 1,
+                skip: 0,
+            });
+            expect(document.operations.global[0]).toMatchObject({
+                type: "INCREMENT",
+                index: 0,
+                skip: 0,
+            });
+        });
+        it("should undo the latest valid operation if undo overlaps with a previous undo operation", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, increment());
+            document = countReducer(document, increment());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            expect(document.revision.global).toBe(9);
+            expect(document.state.global.count).toBe(1);
+            expect(document.clipboard.length).toBe(3);
+            expect(document.clipboard[0].type).toBe("INCREMENT");
+            expect(document.clipboard[0].index).toBe(7);
+            expect(document.clipboard[1].type).toBe("INCREMENT");
+            expect(document.clipboard[1].index).toBe(6);
+            expect(document.clipboard[2].type).toBe("INCREMENT");
+            expect(document.clipboard[2].index).toBe(1);
+            expect(document.operations.global.length).toBe(2);
+            expect(document.operations.global).toMatchObject([
+                {
+                    type: "INCREMENT",
+                    index: 0,
+                    skip: 0,
+                },
+                {
+                    type: "NOOP",
+                    index: 8,
+                    skip: 7,
+                },
+            ]);
+        });
+        it("should undo the latest valid operation if undo overlaps with 2 previous undo operations", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, increment());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, increment());
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            expect(document.revision.global).toBe(10);
+            expect(document.state.global.count).toBe(2);
+            expect(document.clipboard.length).toBe(2);
+            expect(document.clipboard[0].type).toBe("INCREMENT");
+            expect(document.clipboard[0].index).toBe(8);
+            expect(document.clipboard[1].type).toBe("INCREMENT");
+            expect(document.clipboard[1].index).toBe(2);
+            expect(document.operations.global.length).toBe(3);
+            expect(document.operations.global).toMatchObject([
+                {
+                    type: "INCREMENT",
+                    index: 0,
+                    skip: 0,
+                },
+                {
+                    type: "INCREMENT",
+                    index: 1,
+                    skip: 0,
+                },
+                {
+                    type: "NOOP",
+                    index: 9,
+                    skip: 7,
+                },
+            ]);
+        });
+    });
+    describe("REDO", () => {
+        it("should redo the latest operation", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, redo());
+            expect(document.revision.global).toBe(7);
+            expect(document.state.global.count).toBe(4);
+            expect(document.operations.global.length).toBe(5);
+            expect(document.clipboard.length).toBe(1);
+            expect(document.operations.global[4]).toMatchObject({
+                type: "INCREMENT",
+                index: 6,
+            });
+        });
+        it("should revert document state to the latest state before applying an undo", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, redo());
+            document = countReducer(document, redo());
+            expect(document.revision.global).toBe(8);
+            expect(document.state.global.count).toBe(5);
+            expect(document.operations.global.length).toBe(6);
+            expect(document.clipboard.length).toBe(0);
+            expect(document.operations.global[5]).toMatchObject({
+                type: "INCREMENT",
+                index: 7,
+                skip: 0,
+            });
+            expect(document.operations.global[4]).toMatchObject({
+                type: "INCREMENT",
+                index: 6,
+                skip: 0,
+            });
+            expect(document.operations.global[3]).toMatchObject({
+                type: "NOOP",
+                index: 5,
+                skip: 2,
+            });
+            expect(document.operations.global[2]).toMatchObject({
+                type: "INCREMENT",
+                index: 2,
+                skip: 0,
+            });
+            expect(document.operations.global[1]).toMatchObject({
+                type: "INCREMENT",
+                index: 1,
+                skip: 0,
+            });
+            expect(document.operations.global[0]).toMatchObject({
+                type: "INCREMENT",
+                index: 0,
+                skip: 0,
+            });
+        });
+        it("should clean clipboard after applying an action that's not UNDO/REDO", () => {
+            document = countReducer(document, undo());
+            document = countReducer(document, undo());
+            document = countReducer(document, increment());
+            expect(document.revision.global).toBe(7);
+            expect(document.state.global.count).toBe(4);
+            expect(document.operations.global.length).toBe(5);
+            expect(document.clipboard.length).toBe(0);
+        });
+    });
+    describe("NOOP operations", () => {
+        it("should apply NOOP operations", () => {
+            const op = {
+                input: undefined,
+                type: "NOOP",
+                skip: 1,
+                index: 5,
+                scope: "global",
+                hash: "Ki38EB6gkUcnU3ceRsc88njPo3U=",
+                timestamp: new Date().toISOString(),
+            };
+            document = countReducer(document, op, undefined, {
+                skip: 1,
+            });
+            expect(document.revision.global).toBe(6);
+            expect(document.state.global.count).toBe(4);
+            expect(document.operations.global.length).toBe(5);
+            expect(document.operations.global[4]).toMatchObject({
+                type: "NOOP",
+                index: 5,
+                skip: 1,
+            });
+        });
+        it("should replace previous noop operation and update skip number when a new noop is dispatched after another one", () => {
+            const baseOperation = {
+                input: undefined,
+                type: "NOOP",
+                skip: 0,
+                index: 5,
+                scope: "global",
+                hash: "Ki38EB6gkUcnU3ceRsc88njPo3U=",
+                timestamp: new Date().toISOString(),
+            };
+            const op1 = { ...baseOperation, skip: 1 };
+            const op2 = { ...baseOperation, skip: 2 };
+            const op3 = { ...baseOperation, skip: 3 };
+            document = countReducer(document, op1, undefined, { skip: 1 });
+            document = countReducer(document, op2, undefined, { skip: 2 });
+            document = countReducer(document, op3, undefined, { skip: 3 });
+            expect(document.revision.global).toBe(6);
+            expect(document.state.global.count).toBe(2);
+            expect(document.operations.global.length).toBe(3);
+            expect(document.operations.global[2]).toMatchObject({
+                type: "NOOP",
+                index: 5,
+                skip: 3,
+            });
+        });
+        it("NOOP operation should not add skipped operation to the clipboard", () => {
+            const op = {
+                input: undefined,
+                type: "NOOP",
+                skip: 1,
+                index: 5,
+                scope: "global",
+                hash: "Ki38EB6gkUcnU3ceRsc88njPo3U=",
+                timestamp: new Date().toISOString(),
+            };
+            document = countReducer(document, op, undefined, {
+                skip: 1,
+            });
+            expect(document.clipboard.length).toBe(0);
+        });
+    });
+});

package/dist/test/document/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../test/document/utils.test.ts"],"names":[],"mappings":""}

package/dist/test/document/utils.test.js

@@ -0,0 +1,151 @@
+import fs from "fs";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { baseCreateDocument, createReducer, replayDocument, } from "../../src/document/utils/base.js";
+import { generateUUID as generateUUIDBrowser, hash as hashBrowser, } from "../../src/document/utils/browser.js";
+import { getLocalFile } from "../../src/document/utils/file.js";
+import { generateUUID as generateUUIDNode, hash as hashNode, } from "../../src/document/utils/node.js";
+import { validateOperations } from "../../src/document/utils/validation.js";
+import { countReducer, increment, mutableCountReducer, setLocalName, } from "../helpers.js";
+describe("Base utils", () => {
+    const tempDir = "./test/document/temp/utils/";
+    const tempFile = `${tempDir}report.pdf`;
+    beforeAll(() => {
+        if (!fs.existsSync(tempDir))
+            fs.mkdirSync(tempDir, {
+                recursive: true,
+            });
+        fs.writeFileSync(tempFile, "TEST");
+    });
+    afterAll(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("should parse file attributes", async () => {
+        const file = await getLocalFile(tempFile);
+        expect(file).toStrictEqual({
+            data: "VEVTVA==",
+            hash: "Q1pqSc2iiEdpNLjRefhjnQ3nNc8=",
+            mimeType: "application/pdf",
+            extension: "pdf",
+            fileName: "report.pdf",
+        });
+    });
+    it("should throw exception when file doesn't exists", async () => {
+        await expect(getLocalFile("as")).rejects.toBeDefined();
+    });
+    it("should generateId in browser and node", () => {
+        expect(generateUUIDNode()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        expect(generateUUIDBrowser()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        expect(generateUUIDNode().length).toEqual(generateUUIDBrowser().length);
+        expect(generateUUIDNode()).not.toEqual(generateUUIDBrowser());
+    });
+    it("should hash in browser and node", () => {
+        expect(hashNode("test")).toEqual(hashBrowser("test"));
+    });
+    it("should find invalid index oprations", () => {
+        const errors = validateOperations({
+            global: [
+                {
+                    scope: "global",
+                    hash: "",
+                    index: 0,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+                {
+                    scope: "global",
+                    hash: "",
+                    index: 0,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+            ],
+            local: [
+                {
+                    scope: "local",
+                    hash: "",
+                    index: 0,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+            ],
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toStrictEqual("Invalid operation index 0 at position 1");
+    });
+    it("should work with garbage collected operations", () => {
+        const errors = validateOperations({
+            global: [
+                {
+                    scope: "global",
+                    hash: "",
+                    index: 0,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+                {
+                    scope: "global",
+                    hash: "",
+                    index: 1,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+                {
+                    scope: "global",
+                    hash: "",
+                    index: 3,
+                    skip: 1,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+            ],
+            local: [
+                {
+                    scope: "local",
+                    hash: "",
+                    index: 0,
+                    skip: 0,
+                    timestamp: "",
+                    type: "TEST_ACTION",
+                    input: { id: "test" },
+                },
+            ],
+        });
+        expect(errors).toHaveLength(0);
+    });
+    it("should replay document and keep lastModified timestamp", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const newDocument = countReducer(document, setLocalName("test"));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const replayedDocument = replayDocument(document.initialState, newDocument.operations, countReducer, undefined);
+        expect(newDocument.state).toStrictEqual(replayedDocument.state);
+        expect(newDocument.lastModified).toBe(replayedDocument.lastModified);
+        expect(newDocument.operations.global.map((o) => o.timestamp)).toStrictEqual(replayedDocument.operations.global.map((o) => o.timestamp));
+    });
+    it("should work with mutable reducer", () => {
+        const reducer = createReducer(mutableCountReducer);
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const newDocument = reducer(document, increment());
+        expect(newDocument.state.global.count).toBe(1);
+        expect(document.state.global.count).toBe(0);
+        const finalDocument = reducer(newDocument, setLocalName("test"));
+        expect(newDocument.state.local.name).toBe("");
+        expect(finalDocument.state.local.name).toBe("test");
+    });
+});

package/dist/test/document-helpers/addUndo.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addUndo.test.d.ts","sourceRoot":"","sources":["../../../test/document-helpers/addUndo.test.ts"],"names":[],"mappings":""}

package/dist/test/document-helpers/addUndo.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { addUndo, checkOperationsIntegrity, } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("addUndo", () => {
+    const noopScenarios = [
+        {
+            title: "case 1",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 1, type: "NOOP" },
+            ],
+            expected: {
+                length: 5,
+                index: 3,
+                skip: 2,
+            },
+        },
+        {
+            title: "case 2",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 0 },
+                { index: 4, skip: 1, type: "NOOP" },
+            ],
+            expected: {
+                length: 6,
+                index: 4,
+                skip: 2,
+            },
+        },
+        {
+            title: "case 3",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 0 },
+                { index: 4, skip: 0 },
+                { index: 5, skip: 0 },
+                { index: 6, skip: 2, type: "NOOP" },
+            ],
+            expected: {
+                length: 8,
+                index: 6,
+                skip: 3,
+            },
+        },
+        {
+            title: "case 4",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 0 },
+                { index: 4, skip: 2, type: "NOOP" },
+            ],
+            expected: {
+                length: 6,
+                index: 4,
+                skip: 4,
+            },
+        },
+        {
+            title: "case 5",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 1, type: "NOOP" },
+                { index: 3, skip: 2, type: "NOOP" },
+            ],
+            expected: {
+                length: 6,
+                index: 3,
+                skip: 3,
+            },
+        },
+    ];
+    it.each(noopScenarios)("should add NOOP skip nextSkipNumber if latest operation is NOOP: $title", (testInput) => {
+        const operations = buildOperations(testInput.operations);
+        const result = addUndo(operations);
+        const check = checkOperationsIntegrity(result);
+        expect(check).toHaveLength(0);
+        expect(result.length).toBe(testInput.expected.length);
+        const lastOperation = result.pop();
+        expect(lastOperation).toMatchObject({
+            index: testInput.expected.index,
+            skip: testInput.expected.skip,
+            type: "NOOP",
+        });
+    });
+    it("should add NOOP skip 1 if latest operation is not NOOP", () => {
+        const operations = buildOperations([
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+            { index: 2, skip: 0 },
+        ]);
+        const result = addUndo(operations);
+        const check = checkOperationsIntegrity(result);
+        expect(check).toHaveLength(0);
+        expect(result.length).toBe(4);
+        expect(result[3]).toMatchObject({
+            index: 3,
+            skip: 1,
+            type: "NOOP",
+        });
+    });
+    it("should return an empty array unchanged", () => {
+        const operations = buildOperations([]);
+        const result = addUndo(operations);
+        const check = checkOperationsIntegrity(result);
+        expect(check).toHaveLength(0);
+        expect(result.length).toBe(0);
+    });
+});

package/dist/test/document-helpers/attachBranch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachBranch.test.d.ts","sourceRoot":"","sources":["../../../test/document-helpers/attachBranch.test.ts"],"names":[],"mappings":""}