document-model 2.20.0 → 2.21.1

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { attachBranch, checkCleanedOperationsIntegrity, merge, precedes, reshuffleByTimestamp, } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("Conflict resolution", () => {
+    it("should not include duplicated operations when resolving a merge conflict", () => {
+        // target
+        const trunkOperations = buildOperations([
+            {
+                index: 0,
+                skip: 0,
+                type: "T_0",
+                timestamp: "2021-01-01T00:00:00.000Z",
+                id: "1",
+            }, // add folder
+            {
+                index: 1,
+                skip: 0,
+                type: "T_1",
+                timestamp: "2021-01-02T00:00:00.000Z",
+                id: "2",
+            }, // add folder
+            {
+                index: 2,
+                skip: 0,
+                type: "T_2",
+                timestamp: "2021-01-05T00:00:00.000Z",
+                id: "5",
+            }, // 5
+            {
+                index: 3,
+                skip: 0,
+                type: "T_3",
+                timestamp: "2021-01-06T00:00:00.000Z",
+                id: "6",
+            }, // 6
+            {
+                index: 4,
+                skip: 0,
+                type: "T_4",
+                timestamp: "2021-01-07T00:00:00.000Z",
+                id: "7",
+            }, // 7
+            {
+                index: 5,
+                skip: 0,
+                type: "T_5",
+                timestamp: "2021-01-08T00:00:00.000Z",
+                id: "8",
+            }, // 8
+        ]);
+        // new operations
+        const branchOperations = buildOperations([
+            {
+                index: 4,
+                skip: 2,
+                type: "B_4_2",
+                timestamp: "2021-01-03T00:00:00.000Z",
+                id: "3",
+            }, // 3
+            {
+                index: 5,
+                skip: 0,
+                type: "B_5",
+                timestamp: "2021-01-04T00:00:00.000Z",
+                id: "4",
+            }, // 4
+            {
+                index: 6,
+                skip: 0,
+                type: "T_2",
+                timestamp: "2021-01-05T00:00:00.000Z",
+                id: "5",
+            }, // 5
+            {
+                index: 7,
+                skip: 0,
+                type: "T_3",
+                timestamp: "2021-01-06T00:00:00.000Z",
+                id: "6",
+            }, // 6
+        ]);
+        const [newTrunk, tail] = attachBranch(trunkOperations, branchOperations);
+        expect(newTrunk).toMatchObject([
+            { index: 0, skip: 0, type: "T_0" }, // add folder
+            { index: 1, skip: 0, type: "T_1" }, // add folder
+            { index: 4, skip: 2, type: "B_4_2" }, // 3
+            { index: 5, skip: 0, type: "B_5" }, // 4
+            { index: 6, skip: 0, type: "T_2" }, // 5
+            { index: 7, skip: 0, type: "T_3" }, // 6
+        ]);
+        expect(tail).toMatchObject([
+            { index: 4, skip: 0, type: "T_4" }, // 7
+            { index: 5, skip: 0, type: "T_5" }, // 8
+        ]);
+        expect(checkCleanedOperationsIntegrity(newTrunk)).toHaveLength(0);
+        const newHistory = merge(trunkOperations, newTrunk, reshuffleByTimestamp);
+        const newOperations = newHistory.filter((op) => trunkOperations.length < 1 ||
+            precedes(trunkOperations[trunkOperations.length - 1], op));
+        expect(newOperations).toMatchObject([
+            { index: 8, skip: 6, type: "B_4_2", id: "3" }, // 3
+            { index: 9, skip: 0, type: "B_5", id: "4" }, // 4
+            { index: 10, skip: 0, type: "T_2", id: "5" }, // 5
+            { index: 11, skip: 0, type: "T_3", id: "6" }, // 6
+            { index: 12, skip: 0, type: "T_4", id: "7" }, // 7
+            { index: 13, skip: 0, type: "T_5", id: "8" }, // 8
+        ]);
+    });
+});

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

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

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

@@ -0,0 +1,125 @@
+import { describe, expect, it } from "vitest";
+import { filterDuplicatedOperations } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("filterDuplicatedOperations", () => {
+    const scenarios = [
+        {
+            title: "should filter duplicated operations",
+            target: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            source: [
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            result: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+            ],
+        },
+        {
+            title: "should remove all the operations if all of them are duplicated",
+            target: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            source: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            result: [],
+        },
+        {
+            title: "should return empty array if source and target are empty",
+            target: [],
+            source: [],
+            result: [],
+        },
+        {
+            title: "should return empty array if source target is empty",
+            target: [],
+            source: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            result: [],
+        },
+        {
+            title: "should return target operations if source is empty",
+            target: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            source: [],
+            result: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+        },
+        {
+            title: "should return target operations if there is no duplicated operations",
+            target: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+            source: [
+                { index: 4, skip: 0, type: "T_4", id: "4" },
+                { index: 5, skip: 0, type: "T_5", id: "5" },
+                { index: 6, skip: 0, type: "T_6", id: "6" },
+                { index: 7, skip: 0, type: "T_7", id: "7" },
+            ],
+            result: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+            ],
+        },
+        {
+            title: "should remote duplicated operations that are not in order",
+            target: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+                { index: 4, skip: 0, type: "T_4", id: "4" },
+                { index: 5, skip: 0, type: "T_5", id: "5" },
+                { index: 6, skip: 0, type: "T_6", id: "6" },
+                { index: 7, skip: 0, type: "T_7", id: "7" },
+            ],
+            source: [
+                { index: 6, skip: 0, type: "T_6", id: "6" },
+                { index: 3, skip: 0, type: "T_3", id: "3" },
+                { index: 1, skip: 0, type: "T_1", id: "1" },
+                { index: 4, skip: 0, type: "T_4", id: "4" },
+            ],
+            result: [
+                { index: 0, skip: 0, type: "T_0", id: "0" },
+                { index: 2, skip: 0, type: "T_2", id: "2" },
+                { index: 5, skip: 0, type: "T_5", id: "5" },
+                { index: 7, skip: 0, type: "T_7", id: "7" },
+            ],
+        },
+    ];
+    it.each(scenarios)("$title", (testInput) => {
+        const targetOperations = buildOperations(testInput.target);
+        const sourceOperations = buildOperations(testInput.source);
+        const result = filterDuplicatedOperations(targetOperations, sourceOperations);
+        expect(result).toMatchObject(testInput.result);
+    });
+});

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

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

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { garbageCollect, } from "../../src/document/utils/document-helpers.js";
+import { buildOperation, buildOperations } from "./utils.js";
+describe("garbageCollect", () => {
+    it("should return the same list of operations if there is no issues or removals", () => {
+        // 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues
+        const operations = buildOperations([
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+            { index: 2, skip: 0 },
+        ]);
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(operations.length);
+        expect(result).toMatchObject(operations);
+    });
+    it("should remove a single skipped operation", () => {
+        // 0:0 1:1 2:0 => 1:1 2:0, removals 1, no issues
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const op1 = buildOperation({ index: 1, skip: 1 });
+        const op2 = buildOperation({ index: 2, skip: 0 });
+        const operations = [op0, op1, op2];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(2);
+        expect(result).toMatchObject([op1, op2]);
+    });
+    it("should remove all the skipped operations", () => {
+        // 0:0 1:1 2:0 3:1 => 1:1 3:1, removals 2, no issues
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const op1 = buildOperation({ index: 1, skip: 1 });
+        const op2 = buildOperation({ index: 2, skip: 0 });
+        const op3 = buildOperation({ index: 3, skip: 1 });
+        const operations = [op0, op1, op2, op3];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(2);
+        expect(result).toMatchObject([op1, op3]);
+    });
+    it("should keep only the last operation when it skips all the previous operations", () => {
+        // 0:0 1:1 2:0 3:3 => 3:3
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const op1 = buildOperation({ index: 1, skip: 1 });
+        const op2 = buildOperation({ index: 2, skip: 0 });
+        const op3 = buildOperation({ index: 3, skip: 3 });
+        const operations = [op0, op1, op2, op3];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(1);
+        expect(result).toMatchObject([op3]);
+    });
+    it("should not increase removals if an skipped operation is not present", () => {
+        // 1:1 2:0 3:0 => 1:1 2:0 3:0, removals 0, no issues
+        const op0 = buildOperation({ index: 1, skip: 1 });
+        const op1 = buildOperation({ index: 2, skip: 0 });
+        const op2 = buildOperation({ index: 3, skip: 0 });
+        const operations = [op0, op1, op2];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(3);
+        expect(result).toMatchObject(operations);
+    });
+    it("should return an empty array if there is no operations", () => {
+        const result = garbageCollect([]);
+        expect(result).toMatchObject([]);
+    });
+    it("should return the same single operation if there is no skip value", () => {
+        // 0:0 => 0:0
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const operations = [op0];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(1);
+        expect(result).toMatchObject(operations);
+    });
+    it("should return the same single operation if the index and skip value are valid", () => {
+        // 1:1 => 1:1
+        const op0 = buildOperation({ index: 1, skip: 1 });
+        const operations = [op0];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(1);
+        expect(result).toMatchObject(operations);
+    });
+    it("should return only the latest opeartion if all the previous ones are skipped", () => {
+        // [0:0 1:0 2:0 2:1 2:2] => -1
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const op1 = buildOperation({ index: 1, skip: 0 });
+        const op2 = buildOperation({ index: 1, skip: 1 });
+        const op3 = buildOperation({ index: 2, skip: 0 });
+        const op4 = buildOperation({ index: 2, skip: 1 });
+        const op5 = buildOperation({ index: 2, skip: 2 });
+        const operations = [op0, op1, op2, op3, op4, op5];
+        const result = garbageCollect(operations);
+        expect(result.length).toBe(1);
+        expect(result).toMatchObject([op5]);
+    });
+    it("should be indifferent to missing skipped operations", () => {
+        const op0_x = buildOperation({ index: 0, skip: 0 });
+        const op1_v = buildOperation({ index: 1, skip: 1 });
+        const op2_x = buildOperation({ index: 2, skip: 0 });
+        const op3_x = buildOperation({ index: 3, skip: 0 });
+        const op4_x = buildOperation({ index: 4, skip: 0 });
+        const op5_x = buildOperation({ index: 4, skip: 1 });
+        const op6_v = buildOperation({ index: 4, skip: 2 });
+        const equivalentSets = [
+            [op0_x, op1_v, op2_x, op3_x, op4_x, op5_x, op6_v],
+            [op1_v, op2_x, op3_x, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op3_x, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op2_x, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op2_x, op3_x, op5_x, op6_v],
+            [op0_x, op1_v, op2_x, op3_x, op4_x, op6_v],
+            [op1_v, op2_x, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op2_x, op5_x, op6_v],
+            [op0_x, op1_v, op2_x, op4_x, op6_v],
+            [op1_v, op4_x, op5_x, op6_v],
+            [op0_x, op1_v, op5_x, op6_v],
+            [op0_x, op1_v, op4_x, op6_v],
+            [op1_v, op5_x, op6_v],
+            [op0_x, op1_v, op6_v],
+            [op1_v, op6_v],
+        ];
+        for (const set of equivalentSets) {
+            expect(garbageCollect(set)).toEqual([op1_v, op6_v]);
+        }
+    });
+    it("should be idempotent", () => {
+        const op0 = buildOperation({ index: 0, skip: 0 });
+        const op1 = buildOperation({ index: 1, skip: 1 });
+        const op2 = buildOperation({ index: 2, skip: 0 });
+        const op3 = buildOperation({ index: 3, skip: 0 });
+        const op4 = buildOperation({ index: 4, skip: 0 });
+        const op5 = buildOperation({ index: 4, skip: 2 });
+        const operations = [op0, op1, op2, op3, op4, op5];
+        const result = garbageCollect(operations);
+        expect(result).toHaveLength(2);
+        expect(result).toEqual([op1, op5]);
+        const result2 = garbageCollect(result);
+        expect(result2).toEqual(result);
+    });
+});

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

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

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

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { groupOperationsByScope } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("groupOperationsByScope", () => {
+    const scenarios = [
+        {
+            title: "case 1",
+            operations: [
+                { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                { index: 2, skip: 0, scope: "global", hash: "hash3" },
+                { index: 0, skip: 0, scope: "local", hash: "hash4" },
+                { index: 1, skip: 0, scope: "local", hash: "hash5" },
+            ],
+            expected: {
+                global: [
+                    { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                    { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                    { index: 2, skip: 0, scope: "global", hash: "hash3" },
+                ],
+                local: [
+                    { index: 0, skip: 0, scope: "local", hash: "hash4" },
+                    { index: 1, skip: 0, scope: "local", hash: "hash5" },
+                ],
+            },
+        },
+        {
+            title: "case 2",
+            operations: [
+                { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                { index: 0, skip: 0, scope: "local", hash: "hash4" },
+                { index: 2, skip: 0, scope: "global", hash: "hash3" },
+                { index: 1, skip: 0, scope: "local", hash: "hash5" },
+                { index: 3, skip: 0, scope: "global", hash: "hash6" },
+                { index: 3, skip: 0, scope: "local", hash: "hash10" },
+                { index: 4, skip: 0, scope: "global", hash: "hash7" },
+                { index: 5, skip: 0, scope: "global", hash: "hash8" },
+                { index: 2, skip: 0, scope: "local", hash: "hash9" },
+            ],
+            expected: {
+                global: [
+                    { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                    { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                    { index: 2, skip: 0, scope: "global", hash: "hash3" },
+                    { index: 3, skip: 0, scope: "global", hash: "hash6" },
+                    { index: 4, skip: 0, scope: "global", hash: "hash7" },
+                    { index: 5, skip: 0, scope: "global", hash: "hash8" },
+                ],
+                local: [
+                    { index: 0, skip: 0, scope: "local", hash: "hash4" },
+                    { index: 1, skip: 0, scope: "local", hash: "hash5" },
+                    { index: 3, skip: 0, scope: "local", hash: "hash10" },
+                    { index: 2, skip: 0, scope: "local", hash: "hash9" },
+                ],
+            },
+        },
+        {
+            title: "case 3 (only global operations)",
+            operations: [
+                { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                { index: 2, skip: 0, scope: "global", hash: "hash3" },
+            ],
+            expected: {
+                global: [
+                    { index: 0, skip: 0, scope: "global", hash: "hash1" },
+                    { index: 1, skip: 0, scope: "global", hash: "hash2" },
+                    { index: 2, skip: 0, scope: "global", hash: "hash3" },
+                ],
+            },
+        },
+        {
+            title: "case 4 (empty operations)",
+            operations: [],
+            expected: {},
+        },
+        {
+            title: "case 5 (only local operations)",
+            operations: [
+                { index: 0, skip: 0, scope: "local", hash: "hash1" },
+                { index: 1, skip: 0, scope: "local", hash: "hash2" },
+            ],
+            expected: {
+                local: [
+                    { index: 0, skip: 0, scope: "local", hash: "hash1" },
+                    { index: 1, skip: 0, scope: "local", hash: "hash2" },
+                ],
+            },
+        },
+    ];
+    it.each(scenarios)("should group operations by scope: $title", (testInput) => {
+        const operations = buildOperations(testInput.operations);
+        const result = groupOperationsByScope(operations);
+        expect(result).toMatchObject(testInput.expected);
+    });
+});

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

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