@powerhousedao/vetra 4.1.0-dev.9 → 4.1.0-dev.91

package/dist/editors/document-editor/editor.test.js

@@ -0,0 +1,374 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor } from "@testing-library/react";
+import { userEvent } from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useSelectedDocumentEditorDocument } from "../hooks/useVetraDocument.js";
+import { Editor } from "./editor.js";
+vi.mock("../hooks/useVetraDocument.js", () => ({
+    useSelectedDocumentEditorDocument: vi.fn(),
+}));
+vi.mock("../hooks/useAvailableDocumentTypes.js", () => ({
+    useAvailableDocumentTypes: vi.fn(() => [
+        "powerhouse/document-model",
+        "powerhouse/budget-statement",
+        "powerhouse/project-tracker",
+    ]),
+}));
+describe("DocumentEditor Editor", () => {
+    let mockDispatch;
+    beforeEach(() => {
+        mockDispatch = vi.fn();
+        vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+            {
+                state: {
+                    global: {
+                        name: "",
+                        status: "DRAFT",
+                        documentTypes: [],
+                    },
+                },
+            },
+            mockDispatch,
+        ]);
+    });
+    describe("Core Rendering", () => {
+        it("should render all main form sections and labels", () => {
+            render(_jsx(Editor, {}));
+            expect(screen.getByText("Editor Configuration")).toBeInTheDocument();
+            expect(screen.getByText("Editor Name")).toBeInTheDocument();
+            expect(screen.getByText("Supported Document Types")).toBeInTheDocument();
+            expect(screen.getByText("Confirm")).toBeInTheDocument();
+        });
+        it("should display existing editor data when document has values", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            expect(screen.getByDisplayValue("test-editor")).toBeInTheDocument();
+            // Check that the document type appears in the list (not just in dropdown)
+            const documentTypeElements = screen.getAllByText("powerhouse/document-model");
+            expect(documentTypeElements.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Editor Name Input", () => {
+        it("should dispatch setEditorName when name changes (debounced)", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            await user.type(nameInput, "new-editor");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_EDITOR_NAME",
+                    input: { name: "new-editor" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch when clearing a non-empty field", async () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "existing-editor",
+                            status: "DRAFT",
+                            documentTypes: [],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            await user.clear(nameInput);
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_EDITOR_NAME",
+                    input: { name: "" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should NOT dispatch when typing identical value without clearing", async () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test",
+                            status: "DRAFT",
+                            documentTypes: [],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            // Simulate user selecting all text and typing the same value
+            await user.tripleClick(nameInput); // Select all
+            await user.type(nameInput, "test");
+            await waitFor(() => {
+                expect(mockDispatch).not.toHaveBeenCalled();
+            });
+        });
+        it("should NOT dispatch when both old and new values are empty", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            await user.click(nameInput);
+            await user.tab();
+            await waitFor(() => {
+                expect(mockDispatch).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe("Document Types Management", () => {
+        it("should add document type from dropdown", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const select = screen.getByLabelText("Supported Document Types");
+            await user.selectOptions(select, "powerhouse/document-model");
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "ADD_DOCUMENT_TYPE",
+                input: expect.objectContaining({
+                    documentType: "powerhouse/document-model",
+                    id: expect.any(String),
+                }),
+            }));
+        });
+        it("should replace existing document type when adding new one", async () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const select = screen.getByLabelText("Supported Document Types");
+            await user.selectOptions(select, "powerhouse/budget-statement");
+            // Should first remove the existing type
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "REMOVE_DOCUMENT_TYPE",
+                input: { id: "dt-1" },
+            }));
+            // Then add the new type
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "ADD_DOCUMENT_TYPE",
+                input: expect.objectContaining({
+                    documentType: "powerhouse/budget-statement",
+                    id: expect.any(String),
+                }),
+            }));
+        });
+        it("should remove document type", async () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            // Get all instances of the document type text (dropdown + list)
+            const documentModelElements = screen.getAllByText("powerhouse/document-model");
+            // The second one should be in the list (first is in dropdown)
+            const listItem = documentModelElements[1];
+            const removeButton = listItem.parentElement?.querySelector("button");
+            if (removeButton) {
+                await user.click(removeButton);
+            }
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "REMOVE_DOCUMENT_TYPE",
+                input: { id: "dt-1" },
+            }));
+        });
+        it("should display existing document type", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            // Check that the document type appears (it will be in both dropdown and list)
+            const documentTypeElements = screen.getAllByText("powerhouse/document-model");
+            expect(documentTypeElements.length).toBeGreaterThan(0);
+        });
+        it("should show available document types in dropdown", () => {
+            render(_jsx(Editor, {}));
+            const select = screen.getByLabelText("Supported Document Types");
+            const options = Array.from(select.querySelectorAll("option")).map((opt) => opt.value);
+            expect(options).toContain("powerhouse/document-model");
+            expect(options).toContain("powerhouse/budget-statement");
+            expect(options).toContain("powerhouse/project-tracker");
+        });
+    });
+    describe("Confirm Button", () => {
+        it("should dispatch setEditorStatus when confirm clicked", async () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const confirmButton = screen.getByText("Confirm");
+            await user.click(confirmButton);
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "SET_EDITOR_STATUS",
+                input: { status: "CONFIRMED" },
+            }));
+        });
+        it("should be disabled when editor name is empty", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            const confirmButton = screen.getByText("Confirm");
+            expect(confirmButton).toBeDisabled();
+        });
+        it("should be disabled when no document types selected", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            const confirmButton = screen.getByText("Confirm");
+            expect(confirmButton).toBeDisabled();
+        });
+        it("should be hidden when status is CONFIRMED", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "CONFIRMED",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            const confirmButton = screen.queryByText("Confirm");
+            expect(confirmButton).not.toBeInTheDocument();
+        });
+    });
+    describe("Read-only Mode", () => {
+        it("should disable form fields when status is CONFIRMED", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "CONFIRMED",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            expect(nameInput).toBeDisabled();
+            // Document types dropdown should not be visible in read-only mode
+            const select = screen.queryByLabelText("Supported Document Types");
+            expect(select).not.toBeInTheDocument();
+            // Remove button should not be visible
+            const removeButtons = screen.queryAllByText("×");
+            expect(removeButtons).toHaveLength(0);
+        });
+        it("should enable form fields when status is DRAFT", () => {
+            vi.mocked(useSelectedDocumentEditorDocument).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-editor",
+                            status: "DRAFT",
+                            documentTypes: [
+                                { id: "dt-1", documentType: "powerhouse/document-model" },
+                            ],
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Editor Name");
+            expect(nameInput).not.toBeDisabled();
+            // Document types dropdown should be visible
+            const select = screen.getByLabelText("Supported Document Types");
+            expect(select).toBeInTheDocument();
+            // Remove button should be visible
+            const removeButtons = screen.queryAllByText("×");
+            expect(removeButtons.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/editors/document-editor/index.d.ts

@@ -0,0 +1,4 @@
+import type { EditorModule } from "document-model";
+export declare const module: EditorModule;
+export default module;
+//# sourceMappingURL=index.d.ts.map

package/dist/editors/document-editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editors/document-editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,eAAO,MAAM,MAAM,EAAE,YAOpB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/editors/document-editor/index.js

@@ -0,0 +1,10 @@
+import { Editor } from "./editor.js";
+export const module = {
+    Component: Editor,
+    documentTypes: ["powerhouse/document-editor"],
+    config: {
+        id: "document-editor-editor",
+        name: "Document Editor Editor",
+    },
+};
+export default module;

package/dist/editors/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useAvailableDocumentTypes } from "./useAvailableDocumentTypes.js";
+export { useDebounce } from "./useDebounce.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/editors/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editors/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/editors/hooks/index.js

@@ -0,0 +1,2 @@
+export { useAvailableDocumentTypes } from "./useAvailableDocumentTypes.js";
+export { useDebounce } from "./useDebounce.js";

package/dist/editors/hooks/useAvailableDocumentTypes.d.ts

@@ -0,0 +1,2 @@
+export declare function useAvailableDocumentTypes(onlyDocumentTypesFromDriveDocuments?: boolean): string[];
+//# sourceMappingURL=useAvailableDocumentTypes.d.ts.map

package/dist/editors/hooks/useAvailableDocumentTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAvailableDocumentTypes.d.ts","sourceRoot":"","sources":["../../../editors/hooks/useAvailableDocumentTypes.ts"],"names":[],"mappings":"AAYA,wBAAgB,yBAAyB,CACvC,mCAAmC,UAAQ,GAC1C,MAAM,EAAE,CAkBV"}

package/dist/editors/hooks/useAvailableDocumentTypes.js

@@ -0,0 +1,18 @@
+import { useDocumentsInSelectedDrive, useSupportedDocumentTypesInReactor, } from "@powerhousedao/reactor-browser";
+function isDocumentModelDocument(document) {
+    return document.header.documentType === "powerhouse/document-model";
+}
+export function useAvailableDocumentTypes(onlyDocumentTypesFromDriveDocuments = false) {
+    const supportedDocumentTypes = useSupportedDocumentTypesInReactor() ?? [];
+    const documents = useDocumentsInSelectedDrive() ?? [];
+    const documentModelDocumentsInSelectedDrive = documents.filter(isDocumentModelDocument);
+    const documentTypesFromDocumentModelDocuments = documentModelDocumentsInSelectedDrive.map((doc) => doc.state.global.id);
+    if (onlyDocumentTypesFromDriveDocuments)
+        return [...new Set(documentTypesFromDocumentModelDocuments)];
+    return [
+        ...new Set([
+            ...supportedDocumentTypes,
+            ...documentTypesFromDocumentModelDocuments,
+        ]),
+    ];
+}

package/dist/editors/hooks/useDebounce.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reusable debounce hook that calls a callback function after a specified delay
+ * when the value changes. Useful for API calls, search inputs, etc.
+ *
+ * @param value - The value to debounce
+ * @param callback - Function to call with the debounced value (optional)
+ * @param delay - Delay in milliseconds
+ */
+export declare function useDebounce<T>(value: T, callback: ((value: T) => void) | undefined, delay: number): void;
+//# sourceMappingURL=useDebounce.d.ts.map

package/dist/editors/hooks/useDebounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounce.d.ts","sourceRoot":"","sources":["../../../editors/hooks/useDebounce.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EAC1C,KAAK,EAAE,MAAM,QAWd"}

package/dist/editors/hooks/useDebounce.js

@@ -0,0 +1,19 @@
+import { useEffect } from "react";
+/**
+ * Reusable debounce hook that calls a callback function after a specified delay
+ * when the value changes. Useful for API calls, search inputs, etc.
+ *
+ * @param value - The value to debounce
+ * @param callback - Function to call with the debounced value (optional)
+ * @param delay - Delay in milliseconds
+ */
+export function useDebounce(value, callback, delay) {
+    useEffect(() => {
+        if (!callback)
+            return;
+        const timer = setTimeout(() => {
+            callback(value);
+        }, delay);
+        return () => clearTimeout(timer);
+    }, [value, callback, delay]);
+}

package/dist/editors/hooks/useVetraDocument.d.ts

@@ -0,0 +1,17 @@
+import type { AppModuleAction, AppModuleDocument } from "../../document-models/app-module/index.js";
+import { type DocumentEditorDocument } from "../../document-models/document-editor/index.js";
+import type { ProcessorModuleDocument } from "../../document-models/processor-module/index.js";
+import type { SubgraphModuleDocument } from "../../document-models/subgraph-module/index.js";
+import type { VetraPackageDocument } from "../../document-models/vetra-package/index.js";
+export declare function useAppModuleDocument(documentId: string | undefined | null): never[] | [AppModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<AppModuleAction>];
+export declare function useSelectedAppModuleDocument(): never[] | [AppModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<AppModuleAction>];
+export declare function useDocumentEditorDocument(documentId: string | undefined | null): never[] | [DocumentEditorDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/document-editor/gen/actions.js").DocumentEditorBaseOperationsAction>];
+export declare function useSelectedDocumentEditorDocument(): never[] | [DocumentEditorDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/document-editor/gen/actions.js").DocumentEditorBaseOperationsAction>];
+export declare function useProcessorModuleDocument(documentId: string | undefined | null): never[] | [ProcessorModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/processor-module/gen/actions.js").ProcessorModuleBaseOperationsAction>];
+export declare function useSelectedProcessorModuleDocument(): never[] | [ProcessorModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/processor-module/gen/actions.js").ProcessorModuleBaseOperationsAction>];
+export declare function useSubgraphModuleDocument(documentId: string | undefined | null): never[] | [SubgraphModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/subgraph-module/gen/actions.js").SubgraphModuleBaseOperationsAction>];
+export declare function useSelectedSubgraphModuleDocument(): never[] | [SubgraphModuleDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/subgraph-module/gen/actions.js").SubgraphModuleBaseOperationsAction>];
+export declare function useVetraPackageDocument(documentId: string | undefined | null): never[] | [VetraPackageDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/vetra-package/gen/actions.js").VetraPackageBaseOperationsAction>];
+export declare function useSelectedVetraPackageDocument(): [VetraPackageDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/vetra-package/gen/actions.js").VetraPackageBaseOperationsAction>];
+export declare function useSelectedDriveVetraPackage(): never[] | [VetraPackageDocument, import("@powerhousedao/reactor-browser").DocumentDispatch<import("../../document-models/vetra-package/gen/actions.js").VetraPackageBaseOperationsAction>];
+//# sourceMappingURL=useVetraDocument.d.ts.map

package/dist/editors/hooks/useVetraDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVetraDocument.d.ts","sourceRoot":"","sources":["../../../editors/hooks/useVetraDocument.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,iDAAiD,CAAC;AACzD,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,8CAA8C,CAAC;AAOtD,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,6GAKzE;AAED,wBAAgB,4BAA4B,8GAG3C;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,oMAMtC;AAED,wBAAgB,iCAAiC,qMAGhD;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,uMAMtC;AAED,wBAAgB,kCAAkC,wMAGjD;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,oMAMtC;AAED,wBAAgB,iCAAiC,qMAGhD;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,8LAK5E;AAED,wBAAgB,+BAA+B,qLAI9C;AAED,wBAAgB,4BAA4B,+LAQ3C"}

package/dist/editors/hooks/useVetraDocument.js

@@ -0,0 +1,46 @@
+import { useDocumentOfType, useSelectedDocumentId, useSelectedDocumentOfType, useSelectedDrive, } from "@powerhousedao/reactor-browser";
+import { isFileNode } from "document-drive";
+import {} from "../../document-models/document-editor/index.js";
+const VETRA_PACKAGE_DOCUMENT_TYPE = "powerhouse/package";
+const DOCUMENT_EDITOR_DOCUMENT_TYPE = "powerhouse/document-editor";
+const SUBGRAPH_MODULE_DOCUMENT_TYPE = "powerhouse/subgraph";
+const PROCESSOR_MODULE_DOCUMENT_TYPE = "powerhouse/processor";
+export function useAppModuleDocument(documentId) {
+    return useDocumentOfType(documentId, "powerhouse/app");
+}
+export function useSelectedAppModuleDocument() {
+    const documentId = useSelectedDocumentId();
+    return useAppModuleDocument(documentId);
+}
+export function useDocumentEditorDocument(documentId) {
+    return useDocumentOfType(documentId, DOCUMENT_EDITOR_DOCUMENT_TYPE);
+}
+export function useSelectedDocumentEditorDocument() {
+    const documentId = useSelectedDocumentId();
+    return useDocumentEditorDocument(documentId);
+}
+export function useProcessorModuleDocument(documentId) {
+    return useDocumentOfType(documentId, PROCESSOR_MODULE_DOCUMENT_TYPE);
+}
+export function useSelectedProcessorModuleDocument() {
+    const documentId = useSelectedDocumentId();
+    return useProcessorModuleDocument(documentId);
+}
+export function useSubgraphModuleDocument(documentId) {
+    return useDocumentOfType(documentId, SUBGRAPH_MODULE_DOCUMENT_TYPE);
+}
+export function useSelectedSubgraphModuleDocument() {
+    const documentId = useSelectedDocumentId();
+    return useSubgraphModuleDocument(documentId);
+}
+export function useVetraPackageDocument(documentId) {
+    return useDocumentOfType(documentId, VETRA_PACKAGE_DOCUMENT_TYPE);
+}
+export function useSelectedVetraPackageDocument() {
+    return useSelectedDocumentOfType(VETRA_PACKAGE_DOCUMENT_TYPE);
+}
+export function useSelectedDriveVetraPackage() {
+    const [selectedDrive] = useSelectedDrive();
+    const documentId = selectedDrive.state.global.nodes.find((node) => isFileNode(node) && node.documentType === VETRA_PACKAGE_DOCUMENT_TYPE)?.id;
+    return useVetraPackageDocument(documentId);
+}

package/dist/editors/index.d.ts

@@ -1,2 +1,7 @@
-export {};
+export { module as AppEditor } from "./app-editor/index.js";
+export { module as DocumentEditor } from "./document-editor/index.js";
+export { module as ProcessorEditor } from "./processor-editor/index.js";
+export { module as SubgraphEditor } from "./subgraph-editor/index.js";
+export { module as VetraDriveApp } from "./vetra-drive-app/index.js";
+export { module as VetraPackage } from "./vetra-package/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/editors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../editors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../editors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,MAAM,IAAI,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/editors/index.js

@@ -1,2 +1,6 @@
-export {};
-//# sourceMappingURL=index.js.map
+export { module as AppEditor } from "./app-editor/index.js";
+export { module as DocumentEditor } from "./document-editor/index.js";
+export { module as ProcessorEditor } from "./processor-editor/index.js";
+export { module as SubgraphEditor } from "./subgraph-editor/index.js";
+export { module as VetraDriveApp } from "./vetra-drive-app/index.js";
+export { module as VetraPackage } from "./vetra-package/index.js";

package/dist/editors/processor-editor/components/ProcessorEditorForm.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentTypeItem } from "../../../document-models/processor-module/index.js";
+export interface ProcessorEditorFormProps {
+    processorName?: string;
+    processorType?: string;
+    documentTypes?: DocumentTypeItem[];
+    status?: string;
+    onNameChange?: (name: string) => void;
+    onTypeChange?: (type: string) => void;
+    onAddDocumentType?: (id: string, documentType: string) => void;
+    onRemoveDocumentType?: (id: string) => void;
+    onConfirm?: () => void;
+}
+export declare const ProcessorEditorForm: React.FC<ProcessorEditorFormProps>;
+//# sourceMappingURL=ProcessorEditorForm.d.ts.map

package/dist/editors/processor-editor/components/ProcessorEditorForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessorEditorForm.d.ts","sourceRoot":"","sources":["../../../../editors/processor-editor/components/ProcessorEditorForm.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC;AAI3F,MAAM,WAAW,wBAAwB;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,iBAAiB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/D,oBAAoB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAqMlE,CAAC"}