document-model 2.20.0 → 2.21.1

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

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

package/dist/test/document-model/object.test.js

@@ -0,0 +1,242 @@
+import { DocumentModelClass } from "../../src/document-model/gen/object.js";
+import { hashKey } from "../../src/document/utils/base.js";
+describe("DocumentModel Class", () => {
+    it("should create an empty document", () => {
+        const model = new DocumentModelClass();
+        expect(model.name).toBe("");
+        expect(model.documentType).toBe("powerhouse/document-model");
+        expect(model.revision).toBe(0);
+        expect(model.operations.global.length).toBe(0);
+        expect(model.state.global.id).toBe("");
+        expect(model.state.global.name).toBe("");
+        expect(model.state.global.description).toBe("");
+        expect(model.state.global.extension).toBe("");
+        expect(model.state.global.specifications.length).toBe(1);
+        expect(model.state.global.specifications[0].version).toBe(1);
+        expect(model.state.global.specifications[0].changeLog.length).toBe(0);
+        expect(model.state.global.specifications[0].modules.length).toBe(0);
+        expect(model.state.global.author).toEqual({
+            name: "",
+            website: "",
+        });
+    });
+    it("should apply basic operations", () => {
+        const model = new DocumentModelClass();
+        model
+            .setModelId({ id: "<id>" })
+            .setModelName({ name: "<name>" })
+            .setModelDescription({ description: "<description>" })
+            .setModelExtension({ extension: "phdm" })
+            .setAuthorName({ authorName: "<authorName>" })
+            .setAuthorWebsite({ authorWebsite: "<authorWebsite>" });
+        expect(model.state.global.id).toBe("<id>");
+        expect(model.state.global.name).toBe("<name>");
+        expect(model.state.global.description).toBe("<description>");
+        expect(model.state.global.extension).toBe("phdm");
+        expect(model.state.global.author).toEqual({
+            name: "<authorName>",
+            website: "<authorWebsite>",
+        });
+    });
+    it("should apply module operations to the latest specification", () => {
+        const model = new DocumentModelClass();
+        model
+            .addModule({ id: hashKey(), name: "state" })
+            .addModule({ id: hashKey(), name: "header" });
+        expect(model.state.global.specifications[0].modules.map((m) => m.name)).toStrictEqual(["state", "header"]);
+        expect(model.state.global.specifications[0].modules[0].id).toMatch(/^[a-zA-Z0-9+\\/]{27}=$/);
+        expect(model.state.global.specifications[0].modules[0].name).toBe("state");
+        expect(model.state.global.specifications[0].modules[0].description).toBe("");
+        expect(model.state.global.specifications[0].modules[0].operations.length).toBe(0);
+        model.reorderModules({
+            order: [
+                model.state.global.specifications[0].modules[1].id,
+                model.state.global.specifications[0].modules[0].id,
+            ],
+        });
+        expect(model.state.global.specifications[0].modules.map((m) => m.name)).toStrictEqual(["header", "state"]);
+        const headerModuleId = model.state.global.specifications[0].modules[0].id;
+        const stateModuleId = model.state.global.specifications[0].modules[1].id;
+        model.setModuleName({ id: headerModuleId, name: "Header" });
+        model.setModuleDescription({
+            id: headerModuleId,
+            description: "<header description>",
+        });
+        model.deleteModule({ id: stateModuleId });
+        expect(model.state.global.specifications[0].modules).toStrictEqual([
+            {
+                id: headerModuleId,
+                name: "Header",
+                description: "<header description>",
+                operations: [],
+            },
+        ]);
+    });
+    it("should apply operations operations to the latest spec", () => {
+        const model = new DocumentModelClass();
+        model
+            .addModule({ id: hashKey(), name: "header" })
+            .addModule({ id: hashKey(), name: "state" });
+        const headerModuleId = model.state.global.specifications[0].modules[0].id;
+        const stateModuleId = model.state.global.specifications[0].modules[1].id;
+        model.addOperation({
+            id: hashKey(),
+            moduleId: headerModuleId,
+            name: "SetModuleExtension",
+            schema: "<SetModuleExtension.schema>",
+            description: "<SetModuleExtension.description>",
+            template: "<SetModuleExtension.template>",
+            reducer: "<SetModuleExtension.reducer>",
+            scope: "local",
+        });
+        model.addOperation({
+            id: hashKey(),
+            moduleId: stateModuleId,
+            name: "AddStateExample",
+        });
+        const setModuleExtensionId = model.state.global.specifications[0].modules[0].operations[0].id;
+        const addStateExampleId = model.state.global.specifications[0].modules[1].operations[0].id;
+        expect(model.state.global.specifications[0].modules[0]).toEqual({
+            id: headerModuleId,
+            name: "header",
+            description: "",
+            operations: [
+                {
+                    id: setModuleExtensionId,
+                    name: "SetModuleExtension",
+                    schema: "<SetModuleExtension.schema>",
+                    description: "<SetModuleExtension.description>",
+                    template: "<SetModuleExtension.template>",
+                    reducer: "<SetModuleExtension.reducer>",
+                    examples: [],
+                    errors: [],
+                    scope: "local",
+                },
+            ],
+        });
+        expect(model.state.global.specifications[0].modules[1]).toEqual({
+            id: stateModuleId,
+            name: "state",
+            description: "",
+            operations: [
+                {
+                    id: addStateExampleId,
+                    name: "AddStateExample",
+                    schema: "",
+                    description: "",
+                    template: "",
+                    reducer: "",
+                    examples: [],
+                    errors: [],
+                    scope: "global",
+                },
+            ],
+        });
+        model.moveOperation({
+            operationId: setModuleExtensionId,
+            newModuleId: stateModuleId,
+        });
+        expect(model.state.global.specifications[0].modules[0]).toEqual({
+            id: headerModuleId,
+            name: "header",
+            description: "",
+            operations: [],
+        });
+        expect(model.state.global.specifications[0].modules[1]).toEqual({
+            id: stateModuleId,
+            name: "state",
+            description: "",
+            operations: [
+                {
+                    id: addStateExampleId,
+                    name: "AddStateExample",
+                    schema: "",
+                    description: "",
+                    template: "",
+                    reducer: "",
+                    examples: [],
+                    errors: [],
+                    scope: "global",
+                },
+                {
+                    id: setModuleExtensionId,
+                    name: "SetModuleExtension",
+                    schema: "<SetModuleExtension.schema>",
+                    description: "<SetModuleExtension.description>",
+                    template: "<SetModuleExtension.template>",
+                    reducer: "<SetModuleExtension.reducer>",
+                    examples: [],
+                    errors: [],
+                    scope: "local",
+                },
+            ],
+        });
+        model.reorderModuleOperations({
+            moduleId: stateModuleId,
+            order: [setModuleExtensionId, addStateExampleId],
+        });
+        expect(model.state.global.specifications[0].modules[1].operations).toEqual([
+            {
+                id: setModuleExtensionId,
+                name: "SetModuleExtension",
+                schema: "<SetModuleExtension.schema>",
+                description: "<SetModuleExtension.description>",
+                template: "<SetModuleExtension.template>",
+                reducer: "<SetModuleExtension.reducer>",
+                examples: [],
+                errors: [],
+                scope: "local",
+            },
+            {
+                id: addStateExampleId,
+                name: "AddStateExample",
+                schema: "",
+                description: "",
+                template: "",
+                reducer: "",
+                examples: [],
+                errors: [],
+                scope: "global",
+            },
+        ]);
+        model.setOperationName({
+            id: addStateExampleId,
+            name: "SetAuthorName",
+        });
+        model.setOperationSchema({
+            id: addStateExampleId,
+            schema: "<SetAuthorName.schema>",
+        });
+        model.setOperationDescription({
+            id: addStateExampleId,
+            description: "<SetAuthorName.description>",
+        });
+        model.setOperationReducer({
+            id: addStateExampleId,
+            reducer: "<SetAuthorName.reducer>",
+        });
+        model.setOperationTemplate({
+            id: addStateExampleId,
+            template: "<SetAuthorName.template>",
+        });
+        model.setOperationScope({
+            id: addStateExampleId,
+            scope: "local",
+        });
+        const updatedValue = {
+            id: addStateExampleId,
+            name: "SetAuthorName",
+            schema: "<SetAuthorName.schema>",
+            description: "<SetAuthorName.description>",
+            template: "<SetAuthorName.template>",
+            reducer: "<SetAuthorName.reducer>",
+            examples: [],
+            errors: [],
+            scope: "local",
+        };
+        expect(model.state.global.specifications[0].modules[1].operations[1]).toEqual(updatedValue);
+        model.deleteOperation({ id: setModuleExtensionId });
+        expect(model.state.global.specifications[0].modules[1].operations.length).toBe(1);
+        expect(model.state.global.specifications[0].modules[1].operations[0]).toEqual(updatedValue);
+    });
+});

package/dist/test/document-model/replay.test.d.ts.map

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

package/dist/test/document-model/replay.test.js

@@ -0,0 +1,137 @@
+import { noop } from "../../src/document/actions/creators.js";
+import { createReducer, replayDocument, } from "../../src/document/utils/base.js";
+import { baseCountReducer, countReducer, increment, } from "../helpers.js";
+describe("DocumentModel Class", () => {
+    const initialState = {
+        name: "",
+        revision: {
+            global: 0,
+            local: 0,
+        },
+        documentType: "",
+        created: "",
+        lastModified: "",
+        state: {
+            global: {
+                count: 0,
+            },
+            local: {
+                name: "",
+            },
+        },
+        attachments: {},
+    };
+    const initialDocument = {
+        name: "",
+        revision: {
+            global: 0,
+            local: 0,
+        },
+        documentType: "",
+        created: "",
+        lastModified: "",
+        state: {
+            global: {
+                count: 0,
+            },
+            local: {
+                name: "",
+            },
+        },
+        attachments: {},
+        initialState,
+        operations: { global: [], local: [] },
+        clipboard: [],
+    };
+    it("should call reducer once per operation", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment());
+        newDocument = reducer(newDocument, increment());
+        newDocument = reducer(newDocument, increment());
+        newDocument = reducer(newDocument, noop(), undefined, { skip: 1 });
+        expect(mockReducer).toHaveBeenCalledTimes(6);
+        expect(newDocument.state.global.count).toBe(2);
+    });
+    it("should reuse past operation state if available when skipping", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, noop(), undefined, {
+            skip: 1,
+            reuseOperationResultingState: true,
+        });
+        expect(mockReducer).toHaveBeenCalledTimes(4);
+        expect(newDocument.state.global.count).toBe(2);
+    });
+    it("should look for the latest resulting state when replaying the document", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, increment());
+        newDocument = reducer(newDocument, increment());
+        newDocument = reducer(newDocument, noop(), undefined, {
+            skip: 1,
+            reuseOperationResultingState: true,
+        });
+        expect(mockReducer).toHaveBeenCalledTimes(5);
+        expect(newDocument.state.global.count).toBe(2);
+    });
+    it("should replay document", () => {
+        const document = replayDocument(initialState, { global: [], local: [] }, countReducer);
+        expect(initialDocument).toStrictEqual(document);
+    });
+    it("should replay document with operations", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment());
+        newDocument = reducer(newDocument, increment());
+        expect(mockReducer).toHaveBeenCalledTimes(2);
+        const document = replayDocument(initialState, newDocument.operations, reducer);
+        expect(newDocument.state.global.count).toBe(2);
+        expect(newDocument).toStrictEqual(document);
+        expect(mockReducer).toHaveBeenCalledTimes(4);
+    });
+    it("should replay document with undone operations", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment());
+        newDocument = reducer(newDocument, increment());
+        newDocument = reducer(newDocument, noop(), undefined, { skip: 1 });
+        expect(mockReducer).toHaveBeenCalledTimes(4);
+        const document = replayDocument(initialState, newDocument.operations, reducer);
+        expect(mockReducer).toHaveBeenCalledTimes(6);
+        expect(newDocument.state.global.count).toBe(1);
+        expect(newDocument).toStrictEqual(document);
+    });
+    it("should reuse resulting state when replaying document with undone operations", () => {
+        const mockReducer = vi.fn(baseCountReducer);
+        const reducer = createReducer(mockReducer);
+        let newDocument = reducer(initialDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, increment(), undefined, {
+            reuseOperationResultingState: true,
+        });
+        newDocument = reducer(newDocument, noop(), undefined, {
+            skip: 1,
+            reuseOperationResultingState: true,
+        });
+        expect(mockReducer).toHaveBeenCalledTimes(3);
+        expect(newDocument.state.global.count).toBe(1);
+        const document = replayDocument(initialState, newDocument.operations, reducer, undefined, undefined, undefined, { reuseOperationResultingState: true });
+        expect(mockReducer).toHaveBeenCalledTimes(3);
+        expect(document.state.global.count).toBe(1);
+        expect(newDocument).toStrictEqual(document);
+    });
+});

package/dist/test/document-model/skip-operations.test.d.ts.map

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

package/dist/test/document-model/skip-operations.test.js

@@ -0,0 +1,216 @@
+import { setAuthorName, setAuthorWebsite, setModelDescription, setModelExtension, setModelId, setModelName, } from "../../src/document-model/gen/creators.js";
+import { reducer, stateReducer } from "../../src/document-model/gen/reducer.js";
+import { createDocument, createExtendedState, } from "../../src/document-model/gen/utils.js";
+import { replayOperations } from "../../src/document/utils/base.js";
+import { garbageCollectDocumentOperations } from "../../src/document/utils/document-helpers.js";
+describe("Document Operations", () => {
+    describe("Skip header operations", () => {
+        it("should include skip param in base operations with default value to 0 if not provided", () => {
+            let document = createDocument(createExtendedState());
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }));
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in base operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }), undefined, { skip: 6, ignoreSkipOperations: true });
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("Skip module operations", () => {
+        it("should include skip param in module operations with default value to 0 if not provided", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            expect(document.revision).toBe(5);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in module operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            expect(document.revision).toBe(5);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("Skip operation-error operations", () => {
+        it("should include skip param in operation-error operations with default value to 0 if not provided", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }));
+            document = reducer(document, setModelId({ id: "<id2>" }));
+            expect(document.revision).toBe(7);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in operation-error operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }), undefined, { skip: 6, ignoreSkipOperations: true });
+            document = reducer(document, setModelId({ id: "<id2>" }), undefined, {
+                skip: 7,
+                ignoreSkipOperations: true,
+            });
+            expect(document.revision).toBe(7);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("Skip operation-example operations", () => {
+        it("should include skip param in operation-example operations with default value to 0 if not provided", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            expect(document.revision).toBe(5);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in operation-example operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            expect(document.revision).toBe(5);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("Skip operation operations", () => {
+        it("should include skip param in operation operations with default value to 0 if not provided", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }));
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in operation operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }), undefined, { skip: 6, ignoreSkipOperations: true });
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("Skip object operations", () => {
+        it("should include skip param in object operations with default value to 0 if not provided", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }));
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }));
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op) => {
+                expect(op).toHaveProperty("skip", 0);
+            });
+        });
+        it("should include skip param in object operations with provided value", () => {
+            let document = createDocument();
+            document = reducer(document, setModelId({ id: "<id>" }), undefined, {
+                skip: 1,
+                ignoreSkipOperations: true,
+            });
+            document = reducer(document, setModelName({ name: "<name>" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setModelDescription({ description: "<description>" }), undefined, { skip: 3, ignoreSkipOperations: true });
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 4, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }), undefined, { skip: 5, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }), undefined, { skip: 6, ignoreSkipOperations: true });
+            expect(document.revision).toBe(6);
+            document.operations.global.forEach((op, index) => {
+                expect(op).toHaveProperty("skip", index + 1);
+            });
+        });
+    });
+    describe("state replayOperations", () => {
+        it("skipped operations should be ignored when re-calculate document state", () => {
+            const initialState = createExtendedState();
+            let document = createDocument(initialState);
+            document = reducer(document, setModelDescription({ description: "<description>" }));
+            document = reducer(document, setModelName({ name: "<name>" }));
+            document = reducer(document, setModelExtension({ extension: "phdm" }), undefined, { skip: 2, ignoreSkipOperations: true });
+            document = reducer(document, setAuthorName({ authorName: "<authorName>" }));
+            document = reducer(document, setAuthorWebsite({ authorWebsite: "<authorWebsite>" }), undefined, { skip: 1, ignoreSkipOperations: true });
+            document = reducer(document, setModelId({ id: "<id>" }));
+            const replayedDoc = replayOperations(initialState, garbageCollectDocumentOperations(document.operations), stateReducer);
+            expect(replayedDoc.revision.global).toBe(6);
+            expect(replayedDoc.operations.global.length).toBe(3);
+            expect(replayedDoc.state.global).toMatchObject({
+                id: "<id>",
+                name: "",
+                extension: "phdm",
+                description: "",
+                author: { name: "", website: "<authorWebsite>" },
+            });
+        });
+    });
+});

package/dist/test/document-model/validation.test.d.ts.map

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