@powerhousedao/vetra 4.1.0-dev.11 → 4.1.0-dev.111

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

@@ -0,0 +1,330 @@
+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 { useSelectedDriveVetraPackage } from "../hooks/useVetraDocument.js";
+import Editor from "./editor.js";
+vi.mock("../hooks/useVetraDocument.js", () => ({
+    useSelectedDriveVetraPackage: vi.fn(),
+}));
+describe("VetraPackage Editor", () => {
+    let mockDispatch;
+    beforeEach(() => {
+        mockDispatch = vi.fn();
+        vi.mocked(useSelectedDriveVetraPackage).mockReturnValue([
+            {
+                state: {
+                    global: {
+                        name: null,
+                        description: null,
+                        category: null,
+                        author: {
+                            name: null,
+                            website: null,
+                        },
+                        keywords: [],
+                        githubUrl: null,
+                        npmUrl: null,
+                    },
+                },
+            },
+            mockDispatch,
+        ]);
+    });
+    describe("Core Rendering", () => {
+        it("should render all main form sections and labels", () => {
+            render(_jsx(Editor, {}));
+            expect(screen.getByText("Name")).toBeInTheDocument();
+            expect(screen.getByText("Description")).toBeInTheDocument();
+            expect(screen.getByText("Category")).toBeInTheDocument();
+            expect(screen.getByText("Publisher")).toBeInTheDocument();
+            expect(screen.getByText("Publisher URL")).toBeInTheDocument();
+            expect(screen.getByText("Keywords")).toBeInTheDocument();
+            expect(screen.getByText("Github Repository")).toBeInTheDocument();
+            expect(screen.getByText("NPM-package")).toBeInTheDocument();
+        });
+    });
+    describe("Initial Data Display", () => {
+        it("should display existing package data when document has values", () => {
+            vi.mocked(useSelectedDriveVetraPackage).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test-package",
+                            description: "A test package",
+                            category: "Productivity",
+                            author: {
+                                name: "John Doe",
+                                website: "https://johndoe.com",
+                            },
+                            keywords: [
+                                { id: "kw-1", label: "react" },
+                                { id: "kw-2", label: "typescript" },
+                            ],
+                            githubUrl: "https://github.com/test/package",
+                            npmUrl: "https://npmjs.com/package/test",
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            render(_jsx(Editor, {}));
+            expect(screen.getByDisplayValue("test-package")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("A test package")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("Productivity")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("John Doe")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("https://johndoe.com")).toBeInTheDocument();
+            expect(screen.getByText("react")).toBeInTheDocument();
+            expect(screen.getByText("typescript")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("https://github.com/test/package")).toBeInTheDocument();
+            expect(screen.getByDisplayValue("https://npmjs.com/package/test")).toBeInTheDocument();
+        });
+    });
+    describe("Text Input Fields - Dispatch Verification", () => {
+        it("should dispatch setPackageName when name changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Name");
+            await user.type(nameInput, "new-package");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_NAME",
+                    input: { name: "new-package" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch setPackageDescription when description changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const descriptionInput = screen.getByLabelText("Description");
+            await user.type(descriptionInput, "New description");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_DESCRIPTION",
+                    input: { description: "New description" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch setPackageAuthorName when publisher changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const publisherInput = screen.getByLabelText("Publisher");
+            await user.type(publisherInput, "Acme Corp");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_AUTHOR_NAME",
+                    input: { name: "Acme Corp" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch setPackageAuthorWebsite when publisher URL changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const publisherUrlInput = screen.getByLabelText("Publisher URL");
+            await user.type(publisherUrlInput, "https://acme.com");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_AUTHOR_WEBSITE",
+                    input: { website: "https://acme.com" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch setPackageGithubUrl when Github repository changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const githubInput = screen.getByLabelText("Github Repository");
+            await user.type(githubInput, "https://github.com/acme/test");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_GITHUB_URL",
+                    input: { url: "https://github.com/acme/test" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should dispatch setPackageNpmUrl when NPM package changes", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const npmInput = screen.getByLabelText("NPM-package");
+            await user.type(npmInput, "https://npmjs.com/package/acme");
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_NPM_URL",
+                    input: { url: "https://npmjs.com/package/acme" },
+                }));
+            }, { timeout: 500 });
+        });
+    });
+    describe("Conditional Dispatch Logic", () => {
+        it("should dispatch when clearing a non-empty field", async () => {
+            vi.mocked(useSelectedDriveVetraPackage).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "existing-package",
+                            description: null,
+                            category: null,
+                            author: { name: null, website: null },
+                            keywords: [],
+                            githubUrl: null,
+                            npmUrl: null,
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Name");
+            await user.clear(nameInput);
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_NAME",
+                    input: { name: "" },
+                }));
+            }, { timeout: 500 });
+        });
+        it("should NOT dispatch when typing identical value without clearing", async () => {
+            vi.mocked(useSelectedDriveVetraPackage).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: "test",
+                            description: null,
+                            category: null,
+                            author: { name: null, website: null },
+                            keywords: [],
+                            githubUrl: null,
+                            npmUrl: null,
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("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("Name");
+            await user.click(nameInput);
+            await user.tab(); // Focus and blur without typing
+            await waitFor(() => {
+                expect(mockDispatch).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe("Category Selection", () => {
+        it("should dispatch category change immediately (no debounce)", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const categorySelect = screen.getByLabelText("Category");
+            await user.selectOptions(categorySelect, "Productivity");
+            // Should dispatch immediately without waiting for debounce
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "SET_PACKAGE_CATEGORY",
+                input: { category: "Productivity" },
+            }));
+        });
+    });
+    describe("Debounce Behavior", () => {
+        it("should debounce text input changes (300ms delay)", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const nameInput = screen.getByLabelText("Name");
+            // Type multiple characters quickly
+            await user.type(nameInput, "test");
+            // Should not dispatch immediately
+            expect(mockDispatch).not.toHaveBeenCalled();
+            // Should dispatch after debounce delay
+            await waitFor(() => {
+                expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                    type: "SET_PACKAGE_NAME",
+                    input: { name: "test" },
+                }));
+            }, { timeout: 500 });
+        });
+    });
+    describe("Keywords Management", () => {
+        it("should add keyword on Enter with valid input", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const keywordInput = screen.getByPlaceholderText("Type a keyword and press Enter");
+            await user.type(keywordInput, "react{Enter}");
+            expect(screen.getByText("react")).toBeInTheDocument();
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "ADD_PACKAGE_KEYWORD",
+                input: expect.objectContaining({
+                    label: "react",
+                }),
+            }));
+        });
+        it("should NOT add empty or whitespace-only keyword", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            const keywordInput = screen.getByPlaceholderText("Type a keyword and press Enter");
+            // Try to add empty keyword
+            await user.type(keywordInput, "{Enter}");
+            expect(mockDispatch).not.toHaveBeenCalled();
+            // Try to add whitespace-only keyword
+            await user.type(keywordInput, "   {Enter}");
+            expect(mockDispatch).not.toHaveBeenCalled();
+        });
+        it("should display keywords and allow removal", async () => {
+            vi.mocked(useSelectedDriveVetraPackage).mockReturnValue([
+                {
+                    state: {
+                        global: {
+                            name: null,
+                            description: null,
+                            category: null,
+                            author: { name: null, website: null },
+                            keywords: [
+                                { id: "kw-1", label: "react" },
+                                { id: "kw-2", label: "typescript" },
+                            ],
+                            githubUrl: null,
+                            npmUrl: null,
+                        },
+                    },
+                },
+                mockDispatch,
+            ]);
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            expect(screen.getByText("react")).toBeInTheDocument();
+            expect(screen.getByText("typescript")).toBeInTheDocument();
+            // Find and click the remove button for "react"
+            const reactKeyword = screen.getByText("react").closest("span");
+            const removeButton = reactKeyword?.querySelector("button");
+            if (removeButton) {
+                await user.click(removeButton);
+            }
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "REMOVE_PACKAGE_KEYWORD",
+                input: { id: "kw-1" },
+            }));
+        });
+        it("should dispatch addKeyword action with correct payload", async () => {
+            const user = userEvent.setup();
+            render(_jsx(Editor, {}));
+            // Add keyword
+            const keywordInput = screen.getByPlaceholderText("Type a keyword and press Enter");
+            await user.type(keywordInput, "testing{Enter}");
+            expect(mockDispatch).toHaveBeenCalledWith(expect.objectContaining({
+                type: "ADD_PACKAGE_KEYWORD",
+                input: expect.objectContaining({
+                    label: "testing",
+                    id: expect.any(String),
+                }),
+            }));
+        });
+    });
+});

package/dist/editors/vetra-package/module.d.ts

@@ -0,0 +1,4 @@
+import type { EditorModule } from "document-model";
+import { type EditorProps } from "./editor.js";
+export declare const VetraPackageEditor: EditorModule<EditorProps>;
+//# sourceMappingURL=module.d.ts.map

package/dist/editors/vetra-package/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../editors/vetra-package/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAOxD,CAAC"}

package/dist/editors/vetra-package/module.js

@@ -0,0 +1,10 @@
+import { lazy } from "react";
+import {} from "./editor.js";
+export const VetraPackageEditor = {
+    Component: lazy(() => import("./editor.js")),
+    documentTypes: ["powerhouse/package"],
+    config: {
+        id: "vetra-package-editor",
+        name: "Vetra Package Editor",
+    },
+};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Manifest } from "document-model";
+export { documentModels } from "./document-models/document-models.js";
+export { editors } from "./editors/editors.js";
 export declare const manifest: Manifest;
-export declare const documentModels: (import("document-model").DocumentModelModule<import("./document-models/vetra-package/index.js").VetraPackageDocument> | import("document-model").DocumentModelModule<import("./document-models/document-editor/index.js").DocumentEditorDocument>)[];
-export declare const editors: (import("document-model").EditorModule<import("./document-models/document-editor/index.js").DocumentEditorDocument> | import("@powerhousedao/reactor-browser").DriveEditorModule<import("document-drive").DocumentDriveDocument> | import("document-model").EditorModule<import("./document-models/vetra-package/index.js").VetraPackageDocument>)[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK/C,eAAO,MAAM,QAAQ,EAAE,QAAuB,CAAC;AAC/C,eAAO,MAAM,cAAc,uPAAuC,CAAC;AACnE,eAAO,MAAM,OAAO,sVAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,eAAO,MAAM,QAAQ,EAAE,QAAuB,CAAC"}

package/dist/index.js

@@ -1,7 +1,4 @@
-import * as documentModelsExports from './document-models/index.js';
-import * as editorsExports from './editors/index.js';
 import manifestJson from "./powerhouse.manifest.json" with { type: "json" };
+export { documentModels } from "./document-models/document-models.js";
+export { editors } from "./editors/editors.js";
 export const manifest = manifestJson;
-export const documentModels = Object.values(documentModelsExports);
-export const editors = Object.values(editorsExports);
-//# sourceMappingURL=index.js.map

package/dist/powerhouse.manifest.json

@@ -14,6 +14,18 @@
         {
             "id": "powerhouse/document-editor",
             "name": "Document Editor"
+        },
+        {
+            "id": "powerhouse/subgraph-module",
+            "name": "Subgraph Module"
+        },
+        {
+            "id": "powerhouse/processor",
+            "name": "Processor Module"
+        },
+        {
+            "id": "powerhouse/app",
+            "name": "App Module"
         }
     ],
     "editors": [
@@ -26,6 +38,21 @@
             "id": "document-editor-editor",
             "name": "Document Editor",
             "documentTypes": ["powerhouse/document-editor"]
+        },
+        {
+            "id": "subgraph-module-editor",
+            "name": "Subgraph Module Editor",
+            "documentTypes": ["powerhouse/subgraph-module"]
+        },
+        {
+            "id": "processor-module-editor",
+            "name": "Processor Module Editor",
+            "documentTypes": ["powerhouse/processor"]
+        },
+        {
+            "id": "app-module-editor",
+            "name": "App Module Editor",
+            "documentTypes": ["powerhouse/app"]
         }
     ],
     "apps": [

package/dist/processors/codegen/__tests__/codegen-processor-e2e.test.d.ts

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

package/dist/processors/codegen/__tests__/codegen-processor-e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-processor-e2e.test.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/__tests__/codegen-processor-e2e.test.ts"],"names":[],"mappings":""}