@powerhousedao/knowledge-note 1.0.0

package/dist/document-models/knowledge-note/v1/src/reducers/lifecycle.js

@@ -0,0 +1,91 @@
+import { InvalidStatusTransitionError, SelfApprovalError, } from "../../gen/lifecycle/error.js";
+export const knowledgeNoteLifecycleOperations = {
+    submitForReviewOperation(state, action) {
+        if (state.status !== "DRAFT") {
+            throw new InvalidStatusTransitionError("Can only submit for review from DRAFT status");
+        }
+        state.status = "IN_REVIEW";
+        state.lifecycleEvents.push({
+            id: action.input.id,
+            fromStatus: "DRAFT",
+            toStatus: "IN_REVIEW",
+            actor: action.input.actor,
+            timestamp: action.input.timestamp,
+            comment: action.input.comment || null,
+        });
+        if (state.provenance) {
+            state.provenance.updatedAt = action.input.timestamp;
+        }
+    },
+    approveNoteOperation(state, action) {
+        if (state.status !== "IN_REVIEW") {
+            throw new InvalidStatusTransitionError("Can only approve from IN_REVIEW status");
+        }
+        if (state.provenance && state.provenance.author === action.input.actor) {
+            throw new SelfApprovalError("Actor cannot approve their own note");
+        }
+        state.status = "CANONICAL";
+        state.lifecycleEvents.push({
+            id: action.input.id,
+            fromStatus: "IN_REVIEW",
+            toStatus: "CANONICAL",
+            actor: action.input.actor,
+            timestamp: action.input.timestamp,
+            comment: action.input.comment || null,
+        });
+        if (state.provenance) {
+            state.provenance.updatedAt = action.input.timestamp;
+        }
+    },
+    rejectNoteOperation(state, action) {
+        if (state.status !== "IN_REVIEW") {
+            throw new InvalidStatusTransitionError("Can only reject from IN_REVIEW status");
+        }
+        state.status = "DRAFT";
+        state.lifecycleEvents.push({
+            id: action.input.id,
+            fromStatus: "IN_REVIEW",
+            toStatus: "DRAFT",
+            actor: action.input.actor,
+            timestamp: action.input.timestamp,
+            comment: action.input.comment,
+        });
+        if (state.provenance) {
+            state.provenance.updatedAt = action.input.timestamp;
+        }
+    },
+    archiveNoteOperation(state, action) {
+        if (state.status !== "CANONICAL") {
+            throw new InvalidStatusTransitionError("Can only archive from CANONICAL status");
+        }
+        state.status = "ARCHIVED";
+        state.lifecycleEvents.push({
+            id: action.input.id,
+            fromStatus: "CANONICAL",
+            toStatus: "ARCHIVED",
+            actor: action.input.actor,
+            timestamp: action.input.timestamp,
+            comment: action.input.comment,
+        });
+        if (state.provenance) {
+            state.provenance.updatedAt = action.input.timestamp;
+        }
+    },
+    restoreNoteOperation(state, action) {
+        if (state.status !== "ARCHIVED") {
+            throw new InvalidStatusTransitionError("Can only restore from ARCHIVED status");
+        }
+        state.status = "DRAFT";
+        state.lifecycleEvents.push({
+            id: action.input.id,
+            fromStatus: "ARCHIVED",
+            toStatus: "DRAFT",
+            actor: action.input.actor,
+            timestamp: action.input.timestamp,
+            comment: action.input.comment || null,
+        });
+        if (state.provenance) {
+            state.provenance.updatedAt = action.input.timestamp;
+        }
+    },
+};

package/dist/document-models/knowledge-note/v1/src/reducers/linking.d.ts

@@ -0,0 +1,3 @@
+import type { KnowledgeNoteLinkingOperations } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+export declare const knowledgeNoteLinkingOperations: KnowledgeNoteLinkingOperations;
+//# sourceMappingURL=linking.d.ts.map

package/dist/document-models/knowledge-note/v1/src/reducers/linking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linking.d.ts","sourceRoot":"","sources":["../../../../../../document-models/knowledge-note/v1/src/reducers/linking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iEAAiE,CAAC;AAQtH,eAAO,MAAM,8BAA8B,EAAE,8BA+C5C,CAAC"}

package/dist/document-models/knowledge-note/v1/src/reducers/linking.js

@@ -0,0 +1,47 @@
+import { DuplicateLinkIdError, LinkNotFoundError, DuplicateTopicError, TopicNotFoundError, } from "../../gen/linking/error.js";
+export const knowledgeNoteLinkingOperations = {
+    addLinkOperation(state, action) {
+        const existing = state.links.find((l) => l.id === action.input.id);
+        if (existing) {
+            throw new DuplicateLinkIdError("A link with this OID already exists");
+        }
+        state.links.push({
+            id: action.input.id,
+            targetDocumentId: action.input.targetDocumentId,
+            targetTitle: action.input.targetTitle || null,
+            linkType: action.input.linkType,
+        });
+    },
+    removeLinkOperation(state, action) {
+        const index = state.links.findIndex((l) => l.id === action.input.id);
+        if (index === -1) {
+            throw new LinkNotFoundError("No link with this OID");
+        }
+        state.links.splice(index, 1);
+    },
+    updateLinkTypeOperation(state, action) {
+        const link = state.links.find((l) => l.id === action.input.id);
+        if (!link) {
+            throw new LinkNotFoundError("No link with this OID");
+        }
+        link.linkType = action.input.linkType;
+    },
+    addTopicOperation(state, action) {
+        const duplicate = state.topics.find((t) => t.name === action.input.name);
+        if (duplicate) {
+            throw new DuplicateTopicError("A topic with this name already exists on this note");
+        }
+        state.topics.push({
+            id: action.input.id,
+            name: action.input.name,
+            topicDocumentId: action.input.topicDocumentId || null,
+        });
+    },
+    removeTopicOperation(state, action) {
+        const index = state.topics.findIndex((t) => t.id === action.input.id);
+        if (index === -1) {
+            throw new TopicNotFoundError("No topic with this OID");
+        }
+        state.topics.splice(index, 1);
+    },
+};

package/dist/document-models/knowledge-note/v1/src/reducers/local.d.ts

@@ -0,0 +1,3 @@
+import type { KnowledgeNoteLocalOperations } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+export declare const knowledgeNoteLocalOperations: KnowledgeNoteLocalOperations;
+//# sourceMappingURL=local.d.ts.map

package/dist/document-models/knowledge-note/v1/src/reducers/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../../../../document-models/knowledge-note/v1/src/reducers/local.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iEAAiE,CAAC;AAEpH,eAAO,MAAM,4BAA4B,EAAE,4BAI1C,CAAC"}

package/dist/document-models/knowledge-note/v1/src/reducers/local.js

@@ -0,0 +1,5 @@
+export const knowledgeNoteLocalOperations = {
+    setLastViewedOperation(state, action) {
+        state.lastViewedAt = action.input.lastViewedAt;
+    },
+};

package/dist/document-models/knowledge-note/v1/src/reducers/provenance.d.ts

@@ -0,0 +1,3 @@
+import type { KnowledgeNoteProvenanceOperations } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+export declare const knowledgeNoteProvenanceOperations: KnowledgeNoteProvenanceOperations;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/document-models/knowledge-note/v1/src/reducers/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../../../../../document-models/knowledge-note/v1/src/reducers/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,iEAAiE,CAAC;AAEzH,eAAO,MAAM,iCAAiC,EAAE,iCAW7C,CAAC"}

package/dist/document-models/knowledge-note/v1/src/reducers/provenance.js

@@ -0,0 +1,11 @@
+export const knowledgeNoteProvenanceOperations = {
+    setProvenanceOperation(state, action) {
+        state.provenance = {
+            author: action.input.author,
+            sourceOrigin: action.input.sourceOrigin,
+            sessionId: action.input.sessionId || null,
+            createdAt: action.input.createdAt,
+            updatedAt: action.input.createdAt,
+        };
+    },
+};

package/dist/document-models/knowledge-note/v1/src/utils.d.ts

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

package/dist/document-models/knowledge-note/v1/src/utils.d.ts.map

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

package/dist/document-models/knowledge-note/v1/src/utils.js

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

package/dist/document-models/knowledge-note/v1/tests/content.test.d.ts

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

package/dist/document-models/knowledge-note/v1/tests/content.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/tests/content.test.ts"],"names":[],"mappings":""}

package/dist/document-models/knowledge-note/v1/tests/content.test.js

@@ -0,0 +1,75 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isKnowledgeNoteDocument, setTitle, setDescription, setNoteType, setContent, patchContent, setMetadataField, setMetadataListField, SetTitleInputSchema, SetDescriptionInputSchema, SetNoteTypeInputSchema, SetContentInputSchema, PatchContentInputSchema, SetMetadataFieldInputSchema, SetMetadataListFieldInputSchema, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+describe("ContentOperations", () => {
+    it("should handle setTitle operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetTitleInputSchema());
+        const updatedDocument = reducer(document, setTitle(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_TITLE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setDescription operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetDescriptionInputSchema());
+        const updatedDocument = reducer(document, setDescription(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_DESCRIPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setNoteType operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetNoteTypeInputSchema());
+        const updatedDocument = reducer(document, setNoteType(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_NOTE_TYPE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setContent operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetContentInputSchema());
+        const updatedDocument = reducer(document, setContent(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_CONTENT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle patchContent operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(PatchContentInputSchema());
+        const updatedDocument = reducer(document, patchContent(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("PATCH_CONTENT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setMetadataField operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetMetadataFieldInputSchema());
+        const updatedDocument = reducer(document, setMetadataField(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_METADATA_FIELD");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setMetadataListField operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetMetadataListFieldInputSchema());
+        const updatedDocument = reducer(document, setMetadataListField(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_METADATA_LIST_FIELD");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/knowledge-note/v1/tests/document-model.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * 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/knowledge-note/v1/tests/document-model.test.d.ts.map

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

package/dist/document-models/knowledge-note/v1/tests/document-model.test.js

@@ -0,0 +1,104 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * 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, knowledgeNoteDocumentType, isKnowledgeNoteDocument, assertIsKnowledgeNoteDocument, isKnowledgeNoteState, assertIsKnowledgeNoteState, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+import { ZodError } from "zod";
+describe("KnowledgeNote Document Model", () => {
+    it("should create a new KnowledgeNote document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(knowledgeNoteDocumentType);
+    });
+    it("should create a new KnowledgeNote document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isKnowledgeNoteDocument(document)).toBe(true);
+        expect(isKnowledgeNoteState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a KnowledgeNote document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsKnowledgeNoteDocument(wrongDocumentType)).toThrow();
+            expect(isKnowledgeNoteDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    const wrongState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongState.state.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isKnowledgeNoteState(wrongState.state)).toBe(false);
+        expect(assertIsKnowledgeNoteState(wrongState.state)).toThrow();
+        expect(isKnowledgeNoteDocument(wrongState)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(wrongState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const wrongInitialState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongInitialState.initialState.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isKnowledgeNoteState(wrongInitialState.state)).toBe(false);
+        expect(assertIsKnowledgeNoteState(wrongInitialState.state)).toThrow();
+        expect(isKnowledgeNoteDocument(wrongInitialState)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(wrongInitialState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingIdInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingIdInHeader.header.id;
+    try {
+        expect(isKnowledgeNoteDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(missingIdInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingNameInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingNameInHeader.header.name;
+    try {
+        expect(isKnowledgeNoteDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(missingNameInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+    try {
+        expect(isKnowledgeNoteDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(missingCreatedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+    try {
+        expect(isKnowledgeNoteDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsKnowledgeNoteDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/knowledge-note/v1/tests/lifecycle.test.d.ts

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

package/dist/document-models/knowledge-note/v1/tests/lifecycle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/tests/lifecycle.test.ts"],"names":[],"mappings":""}

package/dist/document-models/knowledge-note/v1/tests/lifecycle.test.js

@@ -0,0 +1,55 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isKnowledgeNoteDocument, submitForReview, approveNote, rejectNote, archiveNote, restoreNote, SubmitForReviewInputSchema, ApproveNoteInputSchema, RejectNoteInputSchema, ArchiveNoteInputSchema, RestoreNoteInputSchema, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+describe("LifecycleOperations", () => {
+    it("should handle submitForReview operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SubmitForReviewInputSchema());
+        const updatedDocument = reducer(document, submitForReview(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SUBMIT_FOR_REVIEW");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle approveNote operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ApproveNoteInputSchema());
+        const updatedDocument = reducer(document, approveNote(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("APPROVE_NOTE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle rejectNote operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RejectNoteInputSchema());
+        const updatedDocument = reducer(document, rejectNote(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REJECT_NOTE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle archiveNote operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ArchiveNoteInputSchema());
+        const updatedDocument = reducer(document, archiveNote(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ARCHIVE_NOTE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle restoreNote operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RestoreNoteInputSchema());
+        const updatedDocument = reducer(document, restoreNote(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("RESTORE_NOTE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/knowledge-note/v1/tests/linking.test.d.ts

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

package/dist/document-models/knowledge-note/v1/tests/linking.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linking.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/tests/linking.test.ts"],"names":[],"mappings":""}

package/dist/document-models/knowledge-note/v1/tests/linking.test.js

@@ -0,0 +1,55 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isKnowledgeNoteDocument, addLink, removeLink, updateLinkType, addTopic, removeTopic, AddLinkInputSchema, RemoveLinkInputSchema, UpdateLinkTypeInputSchema, AddTopicInputSchema, RemoveTopicInputSchema, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+describe("LinkingOperations", () => {
+    it("should handle addLink operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddLinkInputSchema());
+        const updatedDocument = reducer(document, addLink(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_LINK");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeLink operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveLinkInputSchema());
+        const updatedDocument = reducer(document, removeLink(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_LINK");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateLinkType operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateLinkTypeInputSchema());
+        const updatedDocument = reducer(document, updateLinkType(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_LINK_TYPE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addTopic operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddTopicInputSchema());
+        const updatedDocument = reducer(document, addTopic(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_TOPIC");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeTopic operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveTopicInputSchema());
+        const updatedDocument = reducer(document, removeTopic(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_TOPIC");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/knowledge-note/v1/tests/local.test.d.ts

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

package/dist/document-models/knowledge-note/v1/tests/local.test.d.ts.map

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

package/dist/document-models/knowledge-note/v1/tests/local.test.js

@@ -0,0 +1,15 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isKnowledgeNoteDocument, setLastViewed, SetLastViewedInputSchema, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+describe("LocalOperations", () => {
+    it("should handle setLastViewed operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetLastViewedInputSchema());
+        const updatedDocument = reducer(document, setLastViewed(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.local).toHaveLength(1);
+        expect(updatedDocument.operations.local[0].action.type).toBe("SET_LAST_VIEWED");
+        expect(updatedDocument.operations.local[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.local[0].index).toEqual(0);
+    });
+});

package/dist/document-models/knowledge-note/v1/tests/provenance.test.d.ts

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

package/dist/document-models/knowledge-note/v1/tests/provenance.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/tests/provenance.test.ts"],"names":[],"mappings":""}

package/dist/document-models/knowledge-note/v1/tests/provenance.test.js

@@ -0,0 +1,15 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isKnowledgeNoteDocument, setProvenance, SetProvenanceInputSchema, } from "@powerhousedao/knowledge-note/document-models/knowledge-note/v1";
+describe("ProvenanceOperations", () => {
+    it("should handle setProvenance operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetProvenanceInputSchema());
+        const updatedDocument = reducer(document, setProvenance(input));
+        expect(isKnowledgeNoteDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_PROVENANCE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/knowledge-note/v1/utils.d.ts

@@ -0,0 +1,14 @@
+import type { KnowledgeNotePHState } from "./gen/types.js";
+/** Utils for the KnowledgeNote document model */
+export declare const utils: {
+    fileExtension: string;
+    createState: import("document-model").CreateState<KnowledgeNotePHState>;
+    createDocument: import("document-model").CreateDocument<KnowledgeNotePHState>;
+    loadFromInput: import("document-model").LoadFromInput<KnowledgeNotePHState>;
+    saveToFileHandle: import("document-model").SaveToFileHandle;
+    isStateOfType: import("document-model").IsStateOfType<KnowledgeNotePHState>;
+    assertIsStateOfType: import("document-model").AssertIsStateOfType<KnowledgeNotePHState>;
+    isDocumentOfType: import("document-model").IsDocumentOfType<KnowledgeNotePHState>;
+    assertIsDocumentOfType: import("document-model").AssertIsDocumentOfType<KnowledgeNotePHState>;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/knowledge-note/v1/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../document-models/knowledge-note/v1/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAI3D,iDAAiD;AACjD,eAAO,MAAM,KAAK;;;;;;;;;;CAGkC,CAAC"}

package/dist/document-models/knowledge-note/v1/utils.js

@@ -0,0 +1,7 @@
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+/** Utils for the KnowledgeNote document model */
+export const utils = {
+    ...genUtils,
+    ...customUtils,
+};

package/dist/document-models/moc/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./v1/index.js";
+export * from "./upgrades/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/moc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../document-models/moc/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC"}

package/dist/document-models/moc/index.js

@@ -0,0 +1,2 @@
+export * from "./v1/index.js";
+export * from "./upgrades/index.js";

package/dist/document-models/moc/upgrades/index.d.ts

@@ -0,0 +1,3 @@
+export { mocUpgradeManifest } from "./upgrade-manifest.js";
+export { supportedVersions, latestVersion } from "./versions.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/moc/upgrades/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../document-models/moc/upgrades/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/document-models/moc/upgrades/index.js

@@ -0,0 +1,2 @@
+export { mocUpgradeManifest } from "./upgrade-manifest.js";
+export { supportedVersions, latestVersion } from "./versions.js";