@powerhousedao/network-admin 0.0.1

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

@@ -0,0 +1,332 @@
+/**
+ * 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("addProposal", () => {
+        it("should add new proposal with all required fields", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-456",
+                title: "Technical Solution Proposal",
+                summary: "Comprehensive technical solution for the RFP requirements",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$50,000",
+                paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+                submittedby: "vendor-789",
+            };
+            const updatedDocument = reducer(document, creators.addProposal(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(1);
+            const proposal = updatedDocument.state.global.proposals[0];
+            expect(proposal.id).toBe("proposal-456");
+            expect(proposal.title).toBe("Technical Solution Proposal");
+            expect(proposal.summary).toBe("Comprehensive technical solution for the RFP requirements");
+            expect(proposal.proposalStatus).toBe("SUBMITTED");
+            expect(proposal.budgetEstimate).toBe("$50,000");
+            expect(proposal.paymentTerms).toBe("MILESTONE_BASED_FIXED_PRICE");
+            expect(proposal.submittedby).toBe("vendor-789");
+        });
+        it("should add proposal with optional submittedby field as null", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-456",
+                title: "Anonymous Proposal",
+                summary: "Proposal without submitter information",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$25,000",
+                paymentTerms: "RETAINER_BASED",
+                submittedby: null,
+            };
+            const updatedDocument = reducer(document, creators.addProposal(input));
+            const proposal = updatedDocument.state.global.proposals[0];
+            expect(proposal.submittedby).toBe(null);
+        });
+        it("should add multiple proposals", () => {
+            let currentDocument = document;
+            // Add first proposal
+            currentDocument = reducer(currentDocument, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-1",
+                title: "First Proposal",
+                summary: "First vendor's solution",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$40,000",
+                paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+            }));
+            // Add second proposal
+            currentDocument = reducer(currentDocument, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-2",
+                title: "Second Proposal",
+                summary: "Second vendor's solution",
+                proposalStatus: "UNDER_REVIEW",
+                budgetEstimate: "$45,000",
+                paymentTerms: "ESCROW",
+            }));
+            expect(currentDocument.state.global.proposals).toHaveLength(2);
+            expect(currentDocument.state.global.proposals[0].title).toBe("First Proposal");
+            expect(currentDocument.state.global.proposals[1].title).toBe("Second Proposal");
+        });
+        it("should handle different payment terms", () => {
+            const paymentTerms = [
+                "MILESTONE_BASED_FIXED_PRICE",
+                "MILESTONE_BASED_ADVANCE_PAYMENT",
+                "RETAINER_BASED",
+                "VARIABLE_COST",
+                "ESCROW",
+            ];
+            let currentDocument = document;
+            paymentTerms.forEach((term, index) => {
+                currentDocument = reducer(currentDocument, creators.addProposal({
+                    rfpId: "rfp-123",
+                    id: `proposal-${index}`,
+                    title: `Proposal ${index + 1}`,
+                    summary: `Proposal with ${term}`,
+                    proposalStatus: "SUBMITTED",
+                    budgetEstimate: `$${(index + 1) * 10000}`,
+                    paymentTerms: term,
+                }));
+            });
+            expect(currentDocument.state.global.proposals).toHaveLength(5);
+            currentDocument.state.global.proposals.forEach((proposal, index) => {
+                expect(proposal.paymentTerms).toBe(paymentTerms[index]);
+            });
+        });
+        it("should handle different proposal statuses", () => {
+            const statuses = [
+                "SUBMITTED",
+                "OPENED",
+                "UNDER_REVIEW",
+                "NEEDS_REVISION",
+                "REVISED",
+                "APPROVED",
+                "CONDITIONALLY_APPROVED",
+                "REJECTED",
+                "WITHDRAWN",
+            ];
+            let currentDocument = document;
+            statuses.forEach((status, index) => {
+                currentDocument = reducer(currentDocument, creators.addProposal({
+                    rfpId: "rfp-123",
+                    id: `proposal-${index}`,
+                    title: `Proposal ${index + 1}`,
+                    summary: `Proposal with status ${status}`,
+                    proposalStatus: status,
+                    budgetEstimate: `$${(index + 1) * 10000}`,
+                    paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+                }));
+            });
+            expect(currentDocument.state.global.proposals).toHaveLength(9);
+            currentDocument.state.global.proposals.forEach((proposal, index) => {
+                expect(proposal.proposalStatus).toBe(statuses[index]);
+            });
+        });
+        it("should handle special characters in title and summary", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-456",
+                title: "Proposal with special chars: & < > \" '",
+                summary: "Summary with emojis: 🚀 💡 📊 and symbols: © ® ™",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$50,000",
+                paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+            };
+            const updatedDocument = reducer(document, creators.addProposal(input));
+            const proposal = updatedDocument.state.global.proposals[0];
+            expect(proposal.title).toBe("Proposal with special chars: & < > \" '");
+            expect(proposal.summary).toBe("Summary with emojis: 🚀 💡 📊 and symbols: © ® ™");
+        });
+    });
+    describe("changeProposalStatus", () => {
+        beforeEach(() => {
+            // Add some proposals to test status changes
+            document = reducer(document, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-1",
+                title: "Proposal 1",
+                summary: "First proposal",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$40,000",
+                paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+            }));
+            document = reducer(document, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-2",
+                title: "Proposal 2",
+                summary: "Second proposal",
+                proposalStatus: "UNDER_REVIEW",
+                budgetEstimate: "$45,000",
+                paymentTerms: "ESCROW",
+            }));
+        });
+        it("should change status of existing proposal", () => {
+            const input = {
+                proposalId: "proposal-1",
+                status: "APPROVED",
+            };
+            const updatedDocument = reducer(document, creators.changeProposalStatus(input));
+            const proposal = updatedDocument.state.global.proposals.find(p => p.id === "proposal-1");
+            expect(proposal.proposalStatus).toBe("APPROVED");
+            // Other proposal should remain unchanged
+            const otherProposal = updatedDocument.state.global.proposals.find(p => p.id === "proposal-2");
+            expect(otherProposal.proposalStatus).toBe("UNDER_REVIEW");
+        });
+        it("should handle status change to all possible statuses", () => {
+            const statuses = [
+                "SUBMITTED",
+                "OPENED",
+                "UNDER_REVIEW",
+                "NEEDS_REVISION",
+                "REVISED",
+                "APPROVED",
+                "CONDITIONALLY_APPROVED",
+                "REJECTED",
+                "WITHDRAWN",
+            ];
+            let currentDocument = document;
+            statuses.forEach((status) => {
+                currentDocument = reducer(currentDocument, creators.changeProposalStatus({
+                    proposalId: "proposal-1",
+                    status: status,
+                }));
+            });
+            const proposal = currentDocument.state.global.proposals.find(p => p.id === "proposal-1");
+            expect(proposal.proposalStatus).toBe("WITHDRAWN"); // Final status
+        });
+        it("should handle non-existent proposal ID gracefully", () => {
+            const input = {
+                proposalId: "non-existent-proposal",
+                status: "APPROVED",
+            };
+            const updatedDocument = reducer(document, creators.changeProposalStatus(input));
+            // All proposals should remain unchanged
+            const proposal1 = updatedDocument.state.global.proposals.find(p => p.id === "proposal-1");
+            const proposal2 = updatedDocument.state.global.proposals.find(p => p.id === "proposal-2");
+            expect(proposal1.proposalStatus).toBe("SUBMITTED");
+            expect(proposal2.proposalStatus).toBe("UNDER_REVIEW");
+        });
+        it("should handle status change on empty proposals array gracefully", () => {
+            const emptyDocument = utils.createDocument();
+            const input = {
+                proposalId: "any-proposal",
+                status: "APPROVED",
+            };
+            const updatedDocument = reducer(emptyDocument, creators.changeProposalStatus(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(0);
+        });
+        it("should preserve all other proposal fields when changing status", () => {
+            const input = {
+                proposalId: "proposal-1",
+                status: "APPROVED",
+            };
+            const updatedDocument = reducer(document, creators.changeProposalStatus(input));
+            const proposal = updatedDocument.state.global.proposals.find(p => p.id === "proposal-1");
+            expect(proposal.title).toBe("Proposal 1");
+            expect(proposal.summary).toBe("First proposal");
+            expect(proposal.budgetEstimate).toBe("$40,000");
+            expect(proposal.paymentTerms).toBe("MILESTONE_BASED_FIXED_PRICE");
+            expect(proposal.proposalStatus).toBe("APPROVED"); // Only this should change
+        });
+    });
+    describe("removeProposal", () => {
+        beforeEach(() => {
+            // Add some proposals to test removal
+            document = reducer(document, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-1",
+                title: "Proposal 1",
+                summary: "First proposal",
+                proposalStatus: "SUBMITTED",
+                budgetEstimate: "$40,000",
+                paymentTerms: "MILESTONE_BASED_FIXED_PRICE",
+            }));
+            document = reducer(document, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-2",
+                title: "Proposal 2",
+                summary: "Second proposal",
+                proposalStatus: "UNDER_REVIEW",
+                budgetEstimate: "$45,000",
+                paymentTerms: "ESCROW",
+            }));
+            document = reducer(document, creators.addProposal({
+                rfpId: "rfp-123",
+                id: "proposal-3",
+                title: "Proposal 3",
+                summary: "Third proposal",
+                proposalStatus: "APPROVED",
+                budgetEstimate: "$50,000",
+                paymentTerms: "RETAINER_BASED",
+            }));
+        });
+        it("should remove existing proposal by ID", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-2",
+            };
+            const updatedDocument = reducer(document, creators.removeProposal(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(2);
+            const remainingIds = updatedDocument.state.global.proposals.map(p => p.id);
+            expect(remainingIds).toContain("proposal-1");
+            expect(remainingIds).toContain("proposal-3");
+            expect(remainingIds).not.toContain("proposal-2");
+        });
+        it("should handle removal of non-existent proposal gracefully", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "non-existent-proposal",
+            };
+            const updatedDocument = reducer(document, creators.removeProposal(input));
+            // All original proposals should remain
+            expect(updatedDocument.state.global.proposals).toHaveLength(3);
+            const remainingIds = updatedDocument.state.global.proposals.map(p => p.id);
+            expect(remainingIds).toContain("proposal-1");
+            expect(remainingIds).toContain("proposal-2");
+            expect(remainingIds).toContain("proposal-3");
+        });
+        it("should handle removal from empty array gracefully", () => {
+            const emptyDocument = utils.createDocument();
+            const input = {
+                rfpId: "rfp-123",
+                id: "any-proposal",
+            };
+            const updatedDocument = reducer(emptyDocument, creators.removeProposal(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(0);
+        });
+        it("should remove first proposal correctly", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-1",
+            };
+            const updatedDocument = reducer(document, creators.removeProposal(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(2);
+            expect(updatedDocument.state.global.proposals[0].id).toBe("proposal-2");
+            expect(updatedDocument.state.global.proposals[1].id).toBe("proposal-3");
+        });
+        it("should remove last proposal correctly", () => {
+            const input = {
+                rfpId: "rfp-123",
+                id: "proposal-3",
+            };
+            const updatedDocument = reducer(document, creators.removeProposal(input));
+            expect(updatedDocument.state.global.proposals).toHaveLength(2);
+            expect(updatedDocument.state.global.proposals[0].id).toBe("proposal-1");
+            expect(updatedDocument.state.global.proposals[1].id).toBe("proposal-2");
+        });
+        it("should remove all proposals when removing each one", () => {
+            let currentDocument = document;
+            // Remove all proposals one by one
+            currentDocument = reducer(currentDocument, creators.removeProposal({ rfpId: "rfp-123", id: "proposal-1" }));
+            currentDocument = reducer(currentDocument, creators.removeProposal({ rfpId: "rfp-123", id: "proposal-2" }));
+            currentDocument = reducer(currentDocument, creators.removeProposal({ rfpId: "rfp-123", id: "proposal-3" }));
+            expect(currentDocument.state.global.proposals).toHaveLength(0);
+        });
+    });
+});

package/dist/document-models/request-for-proposals/src/tests/rfp-state.test.d.ts

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

package/dist/document-models/request-for-proposals/src/tests/rfp-state.test.d.ts.map

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

package/dist/document-models/request-for-proposals/src/tests/rfp-state.test.js

@@ -0,0 +1,243 @@
+/**
+ * Comprehensive tests for RFP State 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/rfp-state/creators.js";
+describe("RFP State Reducers - State Changes", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+    describe("editRfp", () => {
+        it("should update all RFP fields when provided", () => {
+            const input = {
+                title: "New RFP Title",
+                summary: "Updated description for the RFP",
+                eligibilityCriteria: "Criteria 1",
+                evaluationCriteria: "Evaluation 1",
+                status: "OPEN_FOR_PROPOSALS",
+                deadline: "2024-12-31T23:59:59Z",
+                tags: ["technical", "urgent"],
+                budgetRange: {
+                    min: 10000,
+                    max: 50000,
+                    currency: "USD",
+                },
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.title).toBe("New RFP Title");
+            expect(updatedDocument.state.global.summary).toBe("Updated description for the RFP");
+            expect(updatedDocument.state.global.eligibilityCriteria).toEqual(["Criteria 1", "Criteria 2"]);
+            expect(updatedDocument.state.global.evaluationCriteria).toEqual(["Evaluation 1", "Evaluation 2"]);
+            expect(updatedDocument.state.global.status).toBe("OPEN_FOR_PROPOSALS");
+            expect(updatedDocument.state.global.deadline).toBe("2024-12-31T23:59:59Z");
+            expect(updatedDocument.state.global.tags).toEqual(["technical", "urgent"]);
+            expect(updatedDocument.state.global.budgetRange.min).toBe(10000);
+            expect(updatedDocument.state.global.budgetRange.max).toBe(50000);
+            expect(updatedDocument.state.global.budgetRange.currency).toBe("USD");
+        });
+        it("should update only provided fields, leaving others unchanged", () => {
+            // First set some initial values
+            const firstUpdate = reducer(document, creators.editRfp({
+                title: "Initial Title",
+                summary: "Initial description",
+                status: "DRAFT",
+                eligibilityCriteria: "Initial criteria",
+            }));
+            // Then update only some fields
+            const input = {
+                title: "Updated Title",
+                status: "OPEN_FOR_PROPOSALS",
+                tags: ["new-tag"],
+            };
+            const finalDocument = reducer(firstUpdate, creators.editRfp(input));
+            expect(finalDocument.state.global.title).toBe("Updated Title"); // Changed
+            expect(finalDocument.state.global.status).toBe("OPEN_FOR_PROPOSALS"); // Changed
+            expect(finalDocument.state.global.tags).toEqual(["new-tag"]); // Changed
+            expect(finalDocument.state.global.summary).toBe("Initial description"); // Unchanged
+            expect(finalDocument.state.global.eligibilityCriteria).toEqual(["Initial criteria"]); // Unchanged
+        });
+        it("should handle null/undefined values correctly", () => {
+            const input = {
+                title: "Required Title", // Title is required by reducer
+                summary: undefined,
+                status: "DRAFT",
+                eligibilityCriteria: null,
+                evaluationCriteria: undefined,
+                tags: null,
+                budgetRange: {
+                    min: null,
+                    max: undefined,
+                    currency: null,
+                },
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.title).toBe("Required Title");
+            expect(updatedDocument.state.global.summary).toBe(""); // Default value
+            expect(updatedDocument.state.global.status).toBe("DRAFT");
+            expect(updatedDocument.state.global.eligibilityCriteria).toEqual([]); // Default value
+            expect(updatedDocument.state.global.evaluationCriteria).toEqual([]); // Default value
+            expect(updatedDocument.state.global.tags).toBe(null);
+            expect(updatedDocument.state.global.budgetRange.min).toBe(null);
+            expect(updatedDocument.state.global.budgetRange.max).toBe(null);
+            expect(updatedDocument.state.global.budgetRange.currency).toBe(null);
+        });
+        it("should handle empty string values", () => {
+            const input = {
+                title: "",
+                summary: "",
+                status: "DRAFT",
+                eligibilityCriteria: "",
+                evaluationCriteria: "",
+                tags: [],
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.title).toBe("");
+            expect(updatedDocument.state.global.summary).toBe("");
+            expect(updatedDocument.state.global.eligibilityCriteria).toEqual([]);
+            expect(updatedDocument.state.global.evaluationCriteria).toEqual([]);
+            expect(updatedDocument.state.global.tags).toEqual([]);
+        });
+        it("should handle all possible RFP statuses", () => {
+            const statuses = [
+                "DRAFT",
+                "REQUEST_FOR_COMMMENTS",
+                "CANCELED",
+                "OPEN_FOR_PROPOSALS",
+                "AWARDED",
+                "NOT_AWARDED",
+                "CLOSED",
+            ];
+            let currentDocument = document;
+            statuses.forEach((status) => {
+                currentDocument = reducer(currentDocument, creators.editRfp({
+                    title: "Test Title", // Required by reducer
+                    status: status,
+                }));
+            });
+            expect(currentDocument.state.global.status).toBe("CLOSED"); // Final status
+        });
+        it("should handle budget range updates correctly", () => {
+            const input = {
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                budgetRange: {
+                    min: 15000,
+                    max: 75000,
+                    currency: "EUR",
+                },
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.budgetRange.min).toBe(15000);
+            expect(updatedDocument.state.global.budgetRange.max).toBe(75000);
+            expect(updatedDocument.state.global.budgetRange.currency).toBe("EUR");
+        });
+        it("should handle partial budget range updates", () => {
+            // First set a complete budget range
+            let currentDocument = reducer(document, creators.editRfp({
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                budgetRange: {
+                    min: 10000,
+                    max: 50000,
+                    currency: "USD",
+                },
+            }));
+            // Then update only some budget range fields
+            currentDocument = reducer(currentDocument, creators.editRfp({
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                budgetRange: {
+                    min: 20000,
+                    currency: "EUR",
+                },
+            }));
+            expect(currentDocument.state.global.budgetRange.min).toBe(20000);
+            expect(currentDocument.state.global.budgetRange.max).toBe(null); // Undefined becomes null
+            expect(currentDocument.state.global.budgetRange.currency).toBe("EUR");
+        });
+        it("should handle special characters in text fields", () => {
+            const input = {
+                title: "RFP with special chars: & < > \" '",
+                summary: "Description with emojis: 🚀 💡 📊 and symbols: © ® ™",
+                status: "DRAFT",
+                eligibilityCriteria: "Criteria with spaces & symbols!",
+                evaluationCriteria: "Evaluation with numbers: 1, 2, 3",
+                tags: ["tag-with-dashes", "tag_with_underscores", "tag with spaces"],
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.title).toBe("RFP with special chars: & < > \" '");
+            expect(updatedDocument.state.global.summary).toBe("Description with emojis: 🚀 💡 📊 and symbols: © ® ™");
+            expect(updatedDocument.state.global.eligibilityCriteria).toEqual(["Criteria with spaces & symbols!"]);
+            expect(updatedDocument.state.global.evaluationCriteria).toEqual(["Evaluation with numbers: 1, 2, 3"]);
+            expect(updatedDocument.state.global.tags).toEqual(["tag-with-dashes", "tag_with_underscores", "tag with spaces"]);
+        });
+        it("should handle large arrays of criteria and tags", () => {
+            const largeCriteria = Array.from({ length: 100 }, (_, i) => `Criteria ${i + 1}`);
+            const largeTags = Array.from({ length: 50 }, (_, i) => `tag-${i + 1}`);
+            const input = {
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                eligibilityCriteria: largeCriteria.join(", "),
+                evaluationCriteria: largeCriteria.slice(0, 50).join(", "), // Different size
+                tags: largeTags,
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.eligibilityCriteria).toHaveLength(100);
+            expect(updatedDocument.state.global.evaluationCriteria).toHaveLength(50);
+            expect(updatedDocument.state.global.tags).toHaveLength(50);
+            expect(updatedDocument.state.global.eligibilityCriteria[0]).toBe("Criteria 1");
+            expect(updatedDocument.state.global.eligibilityCriteria[99]).toBe("Criteria 100");
+            expect(updatedDocument.state.global.tags[0]).toBe("tag-1");
+            expect(updatedDocument.state.global.tags[49]).toBe("tag-50");
+        });
+        it("should handle ISO date strings correctly", () => {
+            const input = {
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                deadline: "2024-12-31T23:59:59.999Z",
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.deadline).toBe("2024-12-31T23:59:59.999Z");
+        });
+        it("should handle empty budget range", () => {
+            const input = {
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                budgetRange: {
+                    min: null,
+                    max: null,
+                    currency: null,
+                },
+            };
+            const updatedDocument = reducer(document, creators.editRfp(input));
+            expect(updatedDocument.state.global.budgetRange.min).toBe(null);
+            expect(updatedDocument.state.global.budgetRange.max).toBe(null);
+            expect(updatedDocument.state.global.budgetRange.currency).toBe(null);
+        });
+        it("should preserve existing budget range when not provided", () => {
+            // First set a budget range
+            let currentDocument = reducer(document, creators.editRfp({
+                title: "Test Title", // Required by reducer
+                status: "DRAFT",
+                budgetRange: {
+                    min: 10000,
+                    max: 50000,
+                    currency: "USD",
+                },
+            }));
+            // Then update without budget range
+            currentDocument = reducer(currentDocument, creators.editRfp({
+                title: "Test Title", // Required by reducer
+                status: "OPEN_FOR_PROPOSALS",
+            }));
+            // Budget range should remain unchanged
+            expect(currentDocument.state.global.budgetRange.min).toBe(10000);
+            expect(currentDocument.state.global.budgetRange.max).toBe(50000);
+            expect(currentDocument.state.global.budgetRange.currency).toBe("USD");
+            expect(currentDocument.state.global.status).toBe("OPEN_FOR_PROPOSALS"); // Only status changed
+        });
+    });
+});

package/dist/document-models/request-for-proposals/src/utils.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/request-for-proposals/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../document-models/request-for-proposals/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dist/document-models/request-for-proposals/src/utils.js

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

package/dist/document-models/workstream/gen/actions.d.ts

@@ -0,0 +1,6 @@
+import type { WorkstreamWorkstreamAction } from "./workstream/actions.js";
+import type { WorkstreamProposalsAction } from "./proposals/actions.js";
+export * from "./workstream/actions.js";
+export * from "./proposals/actions.js";
+export type WorkstreamAction = WorkstreamWorkstreamAction | WorkstreamProposalsAction;
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/workstream/gen/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../document-models/workstream/gen/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAExE,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GACxB,0BAA0B,GAC1B,yBAAyB,CAAC"}

package/dist/document-models/workstream/gen/actions.js

@@ -0,0 +1,2 @@
+export * from "./workstream/actions.js";
+export * from "./proposals/actions.js";

package/dist/document-models/workstream/gen/creators.d.ts

@@ -0,0 +1,3 @@
+export * from "./workstream/creators.js";
+export * from "./proposals/creators.js";
+//# sourceMappingURL=creators.d.ts.map

package/dist/document-models/workstream/gen/creators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../../../document-models/workstream/gen/creators.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}

package/dist/document-models/workstream/gen/creators.js

@@ -0,0 +1,2 @@
+export * from "./workstream/creators.js";
+export * from "./proposals/creators.js";

package/dist/document-models/workstream/gen/document-model.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentModelState } from "document-model";
+export declare const documentModel: DocumentModelState;
+//# sourceMappingURL=document-model.d.ts.map

package/dist/document-models/workstream/gen/document-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.d.ts","sourceRoot":"","sources":["../../../../document-models/workstream/gen/document-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,eAAO,MAAM,aAAa,EAAE,kBAsJ3B,CAAC"}