@powerhousedao/network-admin 0.0.1

package/dist/document-models/workstream/src/reducers/proposals.js

@@ -0,0 +1,106 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+export const reducer = {
+    editInitialProposalOperation(state, action, dispatch) {
+        const input = action.input;
+        // Create initial proposal if it doesn't exist
+        if (!state.initialProposal) {
+            state.initialProposal = {
+                id: input.id,
+                sow: "", // Will be updated if provided
+                paymentTerms: "", // Will be updated if provided
+                status: "DRAFT",
+                author: {
+                    id: "", // Will be updated if provided
+                    name: null,
+                    icon: null,
+                },
+            };
+        }
+        // Update proposal ID
+        state.initialProposal.id = input.id;
+        // Update optional fields if provided
+        if (input.sowId !== undefined) {
+            state.initialProposal.sow = input.sowId || "";
+        }
+        if (input.paymentTermsId !== undefined) {
+            state.initialProposal.paymentTerms = input.paymentTermsId || "";
+        }
+        if (input.status !== undefined) {
+            state.initialProposal.status = input.status || "DRAFT";
+        }
+        if (input.proposalAuthor !== undefined) {
+            if (input.proposalAuthor) {
+                state.initialProposal.author = {
+                    id: input.proposalAuthor.id,
+                    name: input.proposalAuthor.name || null,
+                    icon: input.proposalAuthor.icon || null,
+                };
+            }
+        }
+    },
+    addAlternativeProposalOperation(state, action, dispatch) {
+        const input = action.input;
+        // Check if proposal with this ID already exists
+        const existingIndex = state.alternativeProposals.findIndex((proposal) => proposal.id === input.id);
+        if (existingIndex === -1) {
+            // Create new alternative proposal
+            const newProposal = {
+                id: input.id,
+                sow: input.sowId || "",
+                paymentTerms: input.paymentTermsId || "",
+                status: input.status || "DRAFT",
+                author: input.proposalAuthor
+                    ? {
+                        id: input.proposalAuthor.id,
+                        name: input.proposalAuthor.name || null,
+                        icon: input.proposalAuthor.icon || null,
+                    }
+                    : {
+                        id: "",
+                        name: null,
+                        icon: null,
+                    },
+            };
+            state.alternativeProposals.push(newProposal);
+        }
+    },
+    editAlternativeProposalOperation(state, action, dispatch) {
+        const input = action.input;
+        // Find the proposal to edit
+        const proposalIndex = state.alternativeProposals.findIndex((proposal) => proposal.id === input.id);
+        if (proposalIndex > -1) {
+            const proposal = state.alternativeProposals[proposalIndex];
+            // Update optional fields if provided
+            if (input.sowId !== undefined) {
+                proposal.sow = input.sowId || "";
+            }
+            if (input.paymentTermsId !== undefined) {
+                proposal.paymentTerms = input.paymentTermsId || "";
+            }
+            if (input.status !== undefined) {
+                proposal.status = input.status || "DRAFT";
+            }
+            if (input.proposalAuthor !== undefined) {
+                if (input.proposalAuthor) {
+                    proposal.author = {
+                        id: input.proposalAuthor.id,
+                        name: input.proposalAuthor.name || null,
+                        icon: input.proposalAuthor.icon || null,
+                    };
+                }
+            }
+        }
+    },
+    removeAlternativeProposalOperation(state, action, dispatch) {
+        const input = action.input;
+        // Find and remove the proposal
+        const proposalIndex = state.alternativeProposals.findIndex((proposal) => proposal.id === input.id);
+        if (proposalIndex > -1) {
+            state.alternativeProposals.splice(proposalIndex, 1);
+        }
+    },
+};

package/dist/document-models/workstream/src/reducers/workstream.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+import type { WorkstreamWorkstreamOperations } from "../../gen/workstream/operations.js";
+export declare const reducer: WorkstreamWorkstreamOperations;
+//# sourceMappingURL=workstream.d.ts.map

package/dist/document-models/workstream/src/reducers/workstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workstream.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/reducers/workstream.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAEzF,eAAO,MAAM,OAAO,EAAE,8BA0ErB,CAAC"}

package/dist/document-models/workstream/src/reducers/workstream.js

@@ -0,0 +1,69 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+export const reducer = {
+    editWorkstreamOperation(state, action, dispatch) {
+        const input = action.input;
+        // Update workstream fields if provided
+        if (input.code !== undefined) {
+            state.code = input.code || null;
+        }
+        if (input.title !== undefined) {
+            state.title = input.title || null;
+        }
+        if (input.status !== undefined) {
+            state.status = input.status || "RFP_DRAFT";
+        }
+        if (input.sowId !== undefined) {
+            state.sow = input.sowId || null;
+        }
+        if (input.paymentTerms !== undefined) {
+            state.paymentTerms = input.paymentTerms || null;
+        }
+    },
+    editClientInfoOperation(state, action, dispatch) {
+        const input = action.input;
+        // Create or update client info
+        if (!state.client) {
+            state.client = {
+                id: input.clientId,
+                name: null,
+                icon: null,
+            };
+        }
+        // Update client ID (required field)
+        state.client.id = input.clientId;
+        // Update optional fields if provided
+        if (input.name !== undefined) {
+            state.client.name = input.name || null;
+        }
+        if (input.icon !== undefined) {
+            state.client.icon = input.icon || null;
+        }
+    },
+    setRequestForProposalOperation(state, action, dispatch) {
+        const input = action.input;
+        // Create or update RFP
+        state.rfp = {
+            id: input.rfpId,
+            title: input.title,
+        };
+    },
+    addPaymentRequestOperation(state, action, dispatch) {
+        const input = action.input;
+        // Add payment request ID if not already present
+        if (!state.paymentRequests.includes(input.id)) {
+            state.paymentRequests.push(input.id);
+        }
+    },
+    removePaymentRequestOperation(state, action, dispatch) {
+        const input = action.input;
+        // Remove payment request ID from the array
+        const index = state.paymentRequests.indexOf(input.id);
+        if (index > -1) {
+            state.paymentRequests.splice(index, 1);
+        }
+    },
+};

package/dist/document-models/workstream/src/tests/document-model.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};
+//# sourceMappingURL=document-model.test.d.ts.map

package/dist/document-models/workstream/src/tests/document-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/document-model.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/document-models/workstream/src/tests/document-model.test.js

@@ -0,0 +1,18 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import utils, { initialGlobalState, initialLocalState, } from "../../gen/utils.js";
+describe("Workstream Document Model", () => {
+    it("should create a new Workstream document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe("powerhouse/workstream");
+    });
+    it("should create a new Workstream document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+    });
+});

package/dist/document-models/workstream/src/tests/proposals-reducers.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Comprehensive tests for Proposals reducers
+ */
+export {};
+//# sourceMappingURL=proposals-reducers.test.d.ts.map

package/dist/document-models/workstream/src/tests/proposals-reducers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals-reducers.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/proposals-reducers.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/document-models/workstream/src/tests/proposals-reducers.test.js

@@ -0,0 +1,316 @@
+/**
+ * Comprehensive tests for Proposals reducers
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import utils from "../../gen/utils.js";
+import { reducer } from "../../gen/reducer.js";
+import * as creators from "../../gen/proposals/creators.js";
+describe("Proposals Reducers - State Changes", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+    describe("editInitialProposal", () => {
+        it("should create initial proposal when it doesn't exist", () => {
+            const author = {
+                id: "author-123",
+                name: "John Doe",
+                icon: "https://example.com/avatar.jpg",
+            };
+            const input = {
+                id: "proposal-123",
+                sowId: "sow-456",
+                paymentTermsId: "terms-789",
+                status: "SUBMITTED",
+                proposalAuthor: author,
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal).toBeDefined();
+            expect(proposal.id).toBe("proposal-123");
+            expect(proposal.sow).toBe("sow-456");
+            expect(proposal.paymentTerms).toBe("terms-789");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe("John Doe");
+            expect(proposal.author.icon).toBe("https://example.com/avatar.jpg");
+        });
+        it("should update existing initial proposal", () => {
+            // First create initial proposal
+            const firstUpdate = reducer(document, creators.editInitialProposal({
+                id: "proposal-123",
+                status: "DRAFT",
+            }));
+            // Then update it
+            const input = {
+                id: "proposal-456",
+                sowId: "sow-789",
+                status: "SUBMITTED",
+                proposalAuthor: {
+                    id: "author-999",
+                    name: "Jane Smith",
+                },
+            };
+            const finalDocument = reducer(firstUpdate, creators.editInitialProposal(input));
+            const proposal = finalDocument.state.global.initialProposal;
+            expect(proposal.id).toBe("proposal-456");
+            expect(proposal.sow).toBe("sow-789");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("author-999");
+            expect(proposal.author.name).toBe("Jane Smith");
+        });
+        it("should handle optional fields correctly", () => {
+            const input = {
+                id: "proposal-123",
+                sowId: undefined,
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.id).toBe("proposal-123");
+            expect(proposal.sow).toBe(""); // Empty when undefined
+            expect(proposal.paymentTerms).toBe(""); // Empty when null
+            expect(proposal.status).toBe("DRAFT"); // Default when undefined
+        });
+        it("should handle empty string values", () => {
+            const input = {
+                id: "proposal-123",
+                sowId: "",
+                paymentTermsId: "",
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+        });
+        it("should handle author with null/undefined optional fields", () => {
+            const input = {
+                id: "proposal-123",
+                proposalAuthor: {
+                    id: "author-123",
+                    name: null,
+                    icon: undefined,
+                },
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe(null);
+            expect(proposal.author.icon).toBe(null);
+        });
+    });
+    describe("addAlternativeProposal", () => {
+        it("should add new alternative proposal", () => {
+            const author = {
+                id: "author-123",
+                name: "Alternative Author",
+                icon: "https://example.com/alt-avatar.jpg",
+            };
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "sow-456",
+                paymentTermsId: "terms-789",
+                status: "DRAFT",
+                proposalAuthor: author,
+            };
+            const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(1);
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.id).toBe("alt-proposal-123");
+            expect(proposal.sow).toBe("sow-456");
+            expect(proposal.paymentTerms).toBe("terms-789");
+            expect(proposal.status).toBe("DRAFT");
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe("Alternative Author");
+            expect(proposal.author.icon).toBe("https://example.com/alt-avatar.jpg");
+        });
+        it("should add multiple alternative proposals", () => {
+            let currentDocument = document;
+            // Add first proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            // Add second proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-2",
+                status: "SUBMITTED",
+            }));
+            expect(currentDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(currentDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-1");
+            expect(currentDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-2");
+        });
+        it("should not add proposal if ID already exists", () => {
+            let currentDocument = document;
+            // Add proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            // Try to add proposal with same ID
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "SUBMITTED",
+            }));
+            expect(currentDocument.state.global.alternativeProposals).toHaveLength(1);
+            expect(currentDocument.state.global.alternativeProposals[0].status).toBe("DRAFT"); // Unchanged
+        });
+        it("should handle optional fields with defaults", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: undefined,
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+            expect(proposal.status).toBe("DRAFT");
+            expect(proposal.author.id).toBe("");
+            expect(proposal.author.name).toBe(null);
+            expect(proposal.author.icon).toBe(null);
+        });
+    });
+    describe("editAlternativeProposal", () => {
+        beforeEach(() => {
+            // Add a proposal to edit
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-123",
+                sowId: "initial-sow",
+                status: "DRAFT",
+                proposalAuthor: {
+                    id: "initial-author",
+                    name: "Initial Author",
+                },
+            }));
+        });
+        it("should edit existing alternative proposal", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "updated-sow",
+                paymentTermsId: "updated-terms",
+                status: "SUBMITTED",
+                proposalAuthor: {
+                    id: "updated-author",
+                    name: "Updated Author",
+                    icon: "https://example.com/updated-avatar.jpg",
+                },
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("updated-sow");
+            expect(proposal.paymentTerms).toBe("updated-terms");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("updated-author");
+            expect(proposal.author.name).toBe("Updated Author");
+            expect(proposal.author.icon).toBe("https://example.com/updated-avatar.jpg");
+        });
+        it("should update only provided fields", () => {
+            const input = {
+                id: "alt-proposal-123",
+                status: "ACCEPTED",
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("initial-sow"); // Unchanged
+            expect(proposal.status).toBe("ACCEPTED"); // Changed
+            expect(proposal.author.name).toBe("Initial Author"); // Unchanged
+        });
+        it("should handle non-existent proposal ID gracefully", () => {
+            const input = {
+                id: "non-existent-proposal",
+                status: "SUBMITTED",
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            // Original proposal should remain unchanged
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.id).toBe("alt-proposal-123");
+            expect(proposal.status).toBe("DRAFT"); // Unchanged
+        });
+        it("should handle optional field updates", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "",
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+            expect(proposal.status).toBe("DRAFT"); // Default when undefined
+        });
+    });
+    describe("removeAlternativeProposal", () => {
+        beforeEach(() => {
+            // Add multiple proposals to test removal
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-2",
+                status: "SUBMITTED",
+            }));
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-3",
+                status: "ACCEPTED",
+            }));
+        });
+        it("should remove existing alternative proposal", () => {
+            const input = {
+                id: "alt-proposal-2",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            const remainingIds = updatedDocument.state.global.alternativeProposals.map((p) => p.id);
+            expect(remainingIds).toContain("alt-proposal-1");
+            expect(remainingIds).toContain("alt-proposal-3");
+            expect(remainingIds).not.toContain("alt-proposal-2");
+        });
+        it("should handle removal of non-existent proposal gracefully", () => {
+            const input = {
+                id: "non-existent-proposal",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            // All original proposals should remain
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(3);
+            const remainingIds = updatedDocument.state.global.alternativeProposals.map((p) => p.id);
+            expect(remainingIds).toContain("alt-proposal-1");
+            expect(remainingIds).toContain("alt-proposal-2");
+            expect(remainingIds).toContain("alt-proposal-3");
+        });
+        it("should handle removal from empty array gracefully", () => {
+            // Start with empty document
+            const emptyDocument = utils.createDocument();
+            const input = {
+                id: "any-proposal",
+            };
+            const updatedDocument = reducer(emptyDocument, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(0);
+        });
+        it("should remove first proposal correctly", () => {
+            const input = {
+                id: "alt-proposal-1",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(updatedDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-2");
+            expect(updatedDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-3");
+        });
+        it("should remove last proposal correctly", () => {
+            const input = {
+                id: "alt-proposal-3",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(updatedDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-1");
+            expect(updatedDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-2");
+        });
+    });
+});

package/dist/document-models/workstream/src/tests/proposals.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};
+//# sourceMappingURL=proposals.test.d.ts.map

package/dist/document-models/workstream/src/tests/proposals.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/proposals.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/document-models/workstream/src/tests/proposals.test.js

@@ -0,0 +1,48 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { generateMock } from "@powerhousedao/codegen";
+import utils from "../../gen/utils.js";
+import { z, } from "../../gen/schema/index.js";
+import { reducer } from "../../gen/reducer.js";
+import * as creators from "../../gen/proposals/creators.js";
+describe("Proposals Operations", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+    it("should handle editInitialProposal operation", () => {
+        const input = generateMock(z.EditInitialProposalInputSchema());
+        const updatedDocument = reducer(document, creators.editInitialProposal(input));
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].type).toBe("EDIT_INITIAL_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addAlternativeProposal operation", () => {
+        const input = generateMock(z.AddAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].type).toBe("ADD_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle editAlternativeProposal operation", () => {
+        const input = generateMock(z.EditAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].type).toBe("EDIT_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeAlternativeProposal operation", () => {
+        const input = generateMock(z.RemoveAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].type).toBe("REMOVE_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/workstream/src/tests/workstream-reducers.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Comprehensive tests for Workstream reducers
+ */
+export {};
+//# sourceMappingURL=workstream-reducers.test.d.ts.map

package/dist/document-models/workstream/src/tests/workstream-reducers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workstream-reducers.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/workstream-reducers.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}