document-model 2.20.0 → 2.21.1

package/dist/src/document-model/gen/versioning/object.js

@@ -0,0 +1,19 @@
+import { BaseDocumentClass } from "../../../document/object.js";
+import { addChangeLogItem, deleteChangeLogItem, releaseNewVersion, reorderChangeLogItems, updateChangeLogItem, } from "./creators.js";
+export default class DocumentModel_Versioning extends BaseDocumentClass {
+    addChangeLogItem(input, options) {
+        return this.dispatch(addChangeLogItem(input), options);
+    }
+    updateChangeLogItem(input, options) {
+        return this.dispatch(updateChangeLogItem(input), options);
+    }
+    deleteChangeLogItem(input, options) {
+        return this.dispatch(deleteChangeLogItem(input), options);
+    }
+    reorderChangeLogItems(input, options) {
+        return this.dispatch(reorderChangeLogItems(input), options);
+    }
+    releaseNewVersion(options) {
+        return this.dispatch(releaseNewVersion(), options);
+    }
+}

package/dist/{browser/src → src}/document-model/gen/versioning/operations.d.ts

@@ -1,5 +1,5 @@
-import { AddChangeLogItemAction, UpdateChangeLogItemAction, DeleteChangeLogItemAction, ReorderChangeLogItemsAction, ReleaseNewVersionAction } from './actions';
-import { DocumentModelState } from '../types';
+import { AddChangeLogItemAction, UpdateChangeLogItemAction, DeleteChangeLogItemAction, ReorderChangeLogItemsAction, ReleaseNewVersionAction } from "./actions.js";
+import { DocumentModelState } from "../types.js";
 export interface DocumentModelVersioningOperations {
     addChangeLogItemOperation: (state: DocumentModelState, action: AddChangeLogItemAction) => void;
     updateChangeLogItemOperation: (state: DocumentModelState, action: UpdateChangeLogItemAction) => void;

package/dist/src/document-model/gen/versioning/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../../src/document-model/gen/versioning/operations.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,iCAAiC;IAChD,yBAAyB,EAAE,CACzB,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,sBAAsB,KAC3B,IAAI,CAAC;IACV,4BAA4B,EAAE,CAC5B,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,yBAAyB,KAC9B,IAAI,CAAC;IACV,4BAA4B,EAAE,CAC5B,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,yBAAyB,KAC9B,IAAI,CAAC;IACV,8BAA8B,EAAE,CAC9B,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,2BAA2B,KAChC,IAAI,CAAC;IACV,0BAA0B,EAAE,CAC1B,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,uBAAuB,KAC5B,IAAI,CAAC;CACX"}

package/dist/src/document-model/gen/versioning/operations.js

@@ -0,0 +1 @@
+export {};

package/dist/src/document-model/module.d.ts

@@ -0,0 +1,3 @@
+import { type DocumentModelDocumentModelModule } from "./types.js";
+export declare const documentModelDocumentModelModule: DocumentModelDocumentModelModule;
+//# sourceMappingURL=module.d.ts.map

package/dist/src/document-model/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/document-model/module.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,gCAAgC,EAAE,gCAM5C,CAAC"}

package/dist/src/document-model/module.js

@@ -0,0 +1,12 @@
+import * as customUtils from "./custom/utils.js";
+import * as actions from "./gen/actions.js";
+import * as creators from "./gen/creators.js";
+import { documentModelState } from "./gen/document-model.js";
+import { reducer } from "./gen/reducer.js";
+import * as documentModelUtils from "./gen/utils.js";
+export const documentModelDocumentModelModule = {
+    reducer,
+    documentModel: documentModelState,
+    actions: { ...creators, ...actions },
+    utils: { ...documentModelUtils, ...customUtils },
+};

package/dist/src/document-model/types.d.ts

@@ -0,0 +1,4 @@
+import { DocumentModelModule } from "../document/types.js";
+import { DocumentModelDocument } from "./gen/types.js";
+export type DocumentModelDocumentModelModule = DocumentModelModule<DocumentModelDocument>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/document-model/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/document-model/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,MAAM,MAAM,gCAAgC,GAC1C,mBAAmB,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/src/document-model/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/test/document/crypto.test.js

@@ -0,0 +1,180 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { baseCreateDocument, hashDocumentStateForScope, } from "../../src/document/utils/base.js";
+import { ab2hex, buildOperationSignatureMessage, buildOperationSignatureParams, buildSignedOperation, hex2ab, verifyOperationSignature, } from "../../src/document/utils/crypto.js";
+import { countReducer, increment } from "../helpers.js";
+describe("Crypto utils", () => {
+    beforeAll(() => {
+        vi.useFakeTimers().setSystemTime(new Date("2024-01-01"));
+    });
+    afterAll(() => {
+        vi.useRealTimers();
+    });
+    it("should build signature with empty previousState", () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const action = {
+            ...increment(),
+            id: "4871aa5f-a53d-4d1c-b5dd-baef4fb17bc2",
+        };
+        const documentWithOp = countReducer(document, action);
+        const operation = documentWithOp.operations.global[0];
+        const signer = {
+            user: { address: "0x123", chainId: 1, networkId: "1" },
+            app: { name: "test", key: "0xtest" },
+        };
+        const params = buildOperationSignatureParams({
+            documentId: "1",
+            operation,
+            signer,
+            previousStateHash: "",
+        });
+        expect(params).toStrictEqual([
+            "1704067200",
+            "0xtest",
+            "ltP0ii+7eM14VIz0UY/SVrZS2ag=",
+            "",
+        ]);
+        const textEncoder = new TextEncoder();
+        expect(buildOperationSignatureMessage(params)).toStrictEqual(textEncoder.encode("\x19Signed Operation:\n4417040672000xtestltP0ii+7eM14VIz0UY/SVrZS2ag="));
+    });
+    it("should build signature with previousState", () => {
+        let document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        document = countReducer(document, increment());
+        const hash = hashDocumentStateForScope(document, "global");
+        const action = {
+            ...increment(),
+            id: "4871aa5f-a53d-4d1c-b5dd-baef4fb17bc2",
+        };
+        const documentWithOp = countReducer(document, action);
+        const operation = documentWithOp.operations.global[1];
+        const signer = {
+            user: { address: "0x123", chainId: 1, networkId: "1" },
+            app: { name: "test", key: "0xtest" },
+        };
+        const params = buildOperationSignatureParams({
+            documentId: "1",
+            operation,
+            signer,
+            previousStateHash: hash,
+        });
+        expect(params).toStrictEqual([
+            "1704067200",
+            "0xtest",
+            "ltP0ii+7eM14VIz0UY/SVrZS2ag=",
+            "qA97yBec1rrOyf2eVsYdWwFPOso=",
+        ]);
+        const textEncoder = new TextEncoder();
+        expect(buildOperationSignatureMessage(params)).toStrictEqual(textEncoder.encode("\x19Signed Operation:\n7217040672000xtestltP0ii+7eM14VIz0UY/SVrZS2ag=qA97yBec1rrOyf2eVsYdWwFPOso="));
+    });
+    it("should build signed operation", async () => {
+        const algorithm = {
+            name: "ECDSA",
+            namedCurve: "P-256",
+            hash: "SHA-256",
+        };
+        const keyPair = await crypto.subtle.generateKey(algorithm, true, [
+            "sign",
+            "verify",
+        ]);
+        const publicKeyRaw = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+        const publicKey = `0x${ab2hex(publicKeyRaw)}`;
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const operation = await buildSignedOperation({ ...increment(), id: "123" }, countReducer, document, {
+            documentId: "1",
+            signer: {
+                user: { address: "0x123", chainId: 1, networkId: "1" },
+                app: { name: "test", key: publicKey },
+            },
+        }, async (data) => new Uint8Array(await crypto.subtle.sign(algorithm, keyPair.privateKey, data.buffer)));
+        expect(operation.context?.signer).toStrictEqual({
+            app: {
+                key: publicKey,
+                name: "test",
+            },
+            signatures: [
+                [
+                    "1704067200",
+                    publicKey,
+                    "oshEuhs/lncjvixPlkOSZiq0OxE=",
+                    "",
+                    expect.stringMatching(/0x[a-f0-9]{128}/),
+                ],
+            ],
+            user: {
+                address: "0x123",
+                chainId: 1,
+                networkId: "1",
+            },
+        });
+    });
+    it("should verify signed operation", async () => {
+        const algorithm = {
+            name: "ECDSA",
+            namedCurve: "P-256",
+            hash: "SHA-256",
+        };
+        const keyPair = await crypto.subtle.generateKey(algorithm, true, [
+            "sign",
+            "verify",
+        ]);
+        const publicKeyRaw = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+        const publicKey = `0x${ab2hex(publicKeyRaw)}`;
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const operation = await buildSignedOperation({ ...increment(), id: "123" }, countReducer, document, {
+            documentId: "1",
+            signer: {
+                user: { address: "0x123", chainId: 1, networkId: "1" },
+                app: { name: "test", key: publicKey },
+            },
+        }, async (data) => new Uint8Array(await crypto.subtle.sign(algorithm, keyPair.privateKey, data.buffer)));
+        const signer = operation.context.signer;
+        const verified = await verifyOperationSignature(signer.signatures.at(0), signer, async (publicKey, signature, data) => {
+            const importedKey = await crypto.subtle.importKey("raw", hex2ab(publicKey), algorithm, true, ["verify"]);
+            return crypto.subtle.verify(algorithm, importedKey, signature, data);
+        });
+        expect(verified).toBe(true);
+    });
+    it("should reject tampered operation signature", async () => {
+        const algorithm = {
+            name: "ECDSA",
+            namedCurve: "P-256",
+            hash: "SHA-256",
+        };
+        const keyPair = await crypto.subtle.generateKey(algorithm, true, [
+            "sign",
+            "verify",
+        ]);
+        const publicKeyRaw = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+        const publicKey = `0x${ab2hex(publicKeyRaw)}`;
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const operation = await buildSignedOperation({ ...increment(), id: "123" }, countReducer, document, {
+            documentId: "1",
+            signer: {
+                user: { address: "0x123", chainId: 1, networkId: "1" },
+                app: { name: "test", key: publicKey },
+            },
+        }, async (data) => new Uint8Array(await crypto.subtle.sign(algorithm, keyPair.privateKey, data.buffer)));
+        const signer = operation.context.signer;
+        const signature = signer.signatures.at(0);
+        signature[4] = "FAKE SIGNATURE";
+        const verified = await verifyOperationSignature(signature, signer, async (publicKey, signature, data) => {
+            const importedKey = await crypto.subtle.importKey("raw", hex2ab(publicKey), algorithm, true, ["verify"]);
+            return crypto.subtle.verify(algorithm, importedKey, signature, data);
+        });
+        expect(verified).toBe(false);
+    });
+});

package/dist/test/document/event-vs-command.test.d.ts.map

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

package/dist/test/document/event-vs-command.test.js

@@ -0,0 +1,168 @@
+// Command = action => should process the action and asign the index, timestamp, and hash
+// Event = operation => should keep the same operation information but execute the action input against the document
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { baseCreateDocument } from "../../src/document/utils/base.js";
+import { wrappedEmptyReducer } from "../helpers.js";
+describe("Event", () => {
+    beforeAll(() => {
+        vi.useFakeTimers().setSystemTime(new Date("2020-01-01"));
+    });
+    it("should not re-assing index to an event", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_2",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_4",
+            input: {},
+            index: 3,
+            hash: "test-4-hash",
+            scope: "global",
+        }, undefined, { skip: 1 });
+        expect(document.revision.global).toBe(4);
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "TEST",
+                index: 0,
+            },
+            {
+                type: "TEST_2",
+                index: 1,
+            },
+            {
+                type: "TEST_4",
+                index: 3,
+                skip: 1,
+            },
+        ]);
+    });
+    it("should remove skipped operations", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_2",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_3",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_4",
+            input: {},
+            index: 3,
+            hash: "test-4-hash",
+            scope: "global",
+        }, undefined, { skip: 1 });
+        expect(document.revision.global).toBe(4);
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "TEST",
+                index: 0,
+            },
+            {
+                type: "TEST_2",
+                index: 1,
+            },
+            {
+                type: "TEST_4",
+                index: 3,
+                skip: 1,
+            },
+        ]);
+    });
+    it("should continue with next index after an operation", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_2",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_4",
+            input: {},
+            index: 3,
+            hash: "test-4-hash",
+            scope: "global",
+        }, undefined, { skip: 1 });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_5",
+            input: {},
+            scope: "global",
+        });
+        expect(document.revision.global).toBe(5);
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "TEST",
+                index: 0,
+            },
+            {
+                type: "TEST_2",
+                index: 1,
+            },
+            {
+                type: "TEST_4",
+                index: 3,
+                skip: 1,
+            },
+            {
+                type: "TEST_5",
+                index: 4,
+            },
+        ]);
+    });
+    it("should calculate the right document revision when last action is an event", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_2",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_4",
+            input: {},
+            index: 3,
+            hash: "test-4-hash",
+            scope: "global",
+        }, undefined, { skip: 1 });
+        expect(document.revision.global).toBe(4);
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "TEST",
+                index: 0,
+            },
+            {
+                type: "TEST_2",
+                index: 1,
+            },
+            {
+                type: "TEST_4",
+                index: 3,
+                skip: 1,
+            },
+        ]);
+    });
+});

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

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

package/dist/test/document/local.test.js

@@ -0,0 +1,247 @@
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { baseCreateDocument } from "../../index.js";
+import { prune, redo, undo } from "../../src/document/actions/creators.js";
+import { countReducer, setLocalName, wrappedEmptyReducer, } from "../helpers.js";
+describe("Local reducer", () => {
+    beforeAll(() => {
+        vi.useFakeTimers().setSystemTime(new Date("2020-01-01"));
+    });
+    it("should update local revision", async () => {
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "local",
+        });
+        expect(newDocument.revision.local).toBe(1);
+    });
+    it("should update lastModified", async () => {
+        vi.useFakeTimers();
+        const document = baseCreateDocument();
+        await new Promise((r) => {
+            setTimeout(r, 100);
+            vi.runOnlyPendingTimers();
+        });
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "local",
+        });
+        expect(new Date(document.lastModified).getTime()).toBeLessThan(new Date(newDocument.lastModified).getTime());
+        vi.useRealTimers();
+    });
+    it("should not update global operations list", async () => {
+        vi.useFakeTimers({ now: new Date("2023-01-01") });
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "local",
+        });
+        expect(newDocument.operations.local).toMatchObject([
+            {
+                type: "TEST",
+                timestamp: new Date().toISOString(),
+                index: 0,
+                skip: 0,
+                input: {},
+                hash: "vyGp6PvFo4RvsFtPoIWeCReyIC8=",
+                scope: "local",
+                error: undefined,
+            },
+        ]);
+        expect(newDocument.operations.global).toStrictEqual([]);
+    });
+    it("should update local operations list", async () => {
+        vi.useFakeTimers({ now: new Date("2023-01-01") });
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "local",
+        });
+        expect(newDocument.operations.local).toMatchObject([
+            {
+                type: "TEST",
+                timestamp: new Date().toISOString(),
+                index: 0,
+                skip: 0,
+                input: {},
+                hash: "vyGp6PvFo4RvsFtPoIWeCReyIC8=",
+                scope: "local",
+                error: undefined,
+            },
+        ]);
+        expect(newDocument.operations.global).toStrictEqual([]);
+    });
+    it("should update local name", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        const newDocument = countReducer(document, setLocalName("test"));
+        expect(newDocument.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "test" },
+        });
+        expect(document.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "" },
+        });
+        expect(newDocument.operations).toMatchObject({
+            global: [],
+            local: [
+                {
+                    hash: "HbiD0GRM+ijPjZ/N3Kw+6WxMTNI=",
+                    type: "SET_LOCAL_NAME",
+                    input: "test",
+                    index: 0,
+                    skip: 0,
+                    scope: "local",
+                    timestamp: new Date().toISOString(),
+                    error: undefined,
+                },
+            ],
+        });
+    });
+    it("should undo local operation", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, setLocalName("test"));
+        expect(newDocument.revision).toStrictEqual({ global: 0, local: 1 });
+        newDocument = countReducer(newDocument, undo(1, "local"));
+        expect(newDocument.revision).toStrictEqual({ global: 0, local: 2 });
+        expect(newDocument.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "" },
+        });
+        expect(document.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "" },
+        });
+        expect(newDocument.operations).toMatchObject({
+            global: [],
+            local: [
+                {
+                    type: "NOOP",
+                    input: {},
+                    index: 1,
+                    skip: 1,
+                    scope: "local",
+                },
+            ],
+        });
+        expect(newDocument.clipboard.length).toBe(1);
+        expect(newDocument.clipboard[0]).toMatchObject({
+            type: "SET_LOCAL_NAME",
+            input: "test",
+            index: 0,
+            skip: 0,
+            scope: "local",
+        });
+    });
+    it("should redo local operation", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, setLocalName("test"));
+        newDocument = countReducer(newDocument, undo(1, "local"));
+        newDocument = countReducer(newDocument, redo(1, "local"));
+        expect(newDocument.revision).toStrictEqual({ global: 0, local: 3 });
+        expect(newDocument.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "test" },
+        });
+        expect(newDocument.clipboard.length).toBe(0);
+        expect(newDocument.operations).toMatchObject({
+            global: [],
+            local: [
+                {
+                    type: "NOOP",
+                    input: {},
+                    index: 1,
+                    skip: 1,
+                    scope: "local",
+                },
+                {
+                    type: "SET_LOCAL_NAME",
+                    input: "test",
+                    index: 2,
+                    skip: 0,
+                    scope: "local",
+                },
+            ],
+        });
+    });
+    it.skip("should prune local operations", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, setLocalName("test"));
+        newDocument = countReducer(newDocument, setLocalName("test 2"));
+        expect(newDocument.revision).toStrictEqual({ global: 0, local: 2 });
+        expect(newDocument.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "test 2" },
+        });
+        expect(newDocument.operations).toStrictEqual({
+            global: [],
+            local: [
+                {
+                    hash: "HbiD0GRM+ijPjZ/N3Kw+6WxMTNI=",
+                    type: "SET_LOCAL_NAME",
+                    input: "test",
+                    index: 0,
+                    skip: 0,
+                    scope: "local",
+                    timestamp: new Date().toISOString(),
+                    error: undefined,
+                },
+                {
+                    hash: "QIsBfXG+5+X+ju/tv2PHkg0SyEM=",
+                    type: "SET_LOCAL_NAME",
+                    input: "test 2",
+                    index: 1,
+                    skip: 0,
+                    scope: "local",
+                    timestamp: new Date().toISOString(),
+                    error: undefined,
+                },
+            ],
+        });
+        newDocument = countReducer(newDocument, prune(0, undefined, "local"));
+        expect(newDocument.revision).toStrictEqual({ global: 1, local: 0 });
+        expect(newDocument.state).toStrictEqual({
+            global: { count: 0 },
+            local: { name: "test 2" },
+        });
+        expect(newDocument.operations).toStrictEqual({
+            global: [
+                {
+                    error: undefined,
+                    hash: "ch7MNww9+xUYoTgutbGr6VU0GaU=",
+                    type: "LOAD_STATE",
+                    input: {
+                        operations: 2,
+                        state: {
+                            name: "",
+                            state: {
+                                global: { count: 0 },
+                                local: { name: "test 2" },
+                            },
+                        },
+                    },
+                    index: 0,
+                    skip: 0,
+                    scope: "global",
+                    timestamp: new Date().toISOString(),
+                },
+            ],
+            local: [],
+        });
+    });
+});

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

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