@powerhousedao/codegen 5.1.0-dev.2 → 5.1.0-dev.4

package/dist/src/ts-morph-utils/templates/document-model/src/tests/document-model.test.js

@@ -0,0 +1,121 @@
+import { ts } from "@tmpl/core";
+export const documentModelTestFileTemplate = (v) => ts `
+/**
+ * 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,
+  ${v.documentTypeVariableName},
+  ${v.isPhDocumentOfTypeFunctionName},
+  ${v.assertIsPhDocumentOfTypeFunctionName},
+  ${v.isPhStateOfTypeFunctionName},
+  ${v.assertIsPhStateOfTypeFunctionName},
+} from "${v.documentModelDir}";
+import { ZodError } from "zod";
+
+describe("${v.pascalCaseDocumentType} Document Model", () => {
+  it("should create a new ${v.pascalCaseDocumentType} document", () => {
+    const document = utils.createDocument();
+
+    expect(document).toBeDefined();
+    expect(document.header.documentType).toBe(${v.documentTypeVariableName});
+  });
+
+  it("should create a new ${v.pascalCaseDocumentType} document with a valid initial state", () => {
+    const document = utils.createDocument();
+    expect(document.state.global).toStrictEqual(initialGlobalState);
+    expect(document.state.local).toStrictEqual(initialLocalState);
+    expect(${v.isPhDocumentOfTypeFunctionName}(document)).toBe(true);
+    expect(${v.isPhStateOfTypeFunctionName}(document.state)).toBe(true);
+  });
+  it("should reject a document that is not a ${v.pascalCaseDocumentType} document", () => {
+    const wrongDocumentType = utils.createDocument();
+    wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+    try {
+      expect(${v.assertIsPhDocumentOfTypeFunctionName}(wrongDocumentType)).toThrow();
+      expect(${v.isPhDocumentOfTypeFunctionName}(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(${v.isPhStateOfTypeFunctionName}(wrongState.state)).toBe(false);
+    expect(${v.assertIsPhStateOfTypeFunctionName}(wrongState.state)).toThrow();
+    expect(${v.isPhDocumentOfTypeFunctionName}(wrongState)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(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(${v.isPhStateOfTypeFunctionName}(wrongInitialState.state)).toBe(false);
+    expect(${v.assertIsPhStateOfTypeFunctionName}(wrongInitialState.state)).toThrow();
+    expect(${v.isPhDocumentOfTypeFunctionName}(wrongInitialState)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(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(${v.isPhDocumentOfTypeFunctionName}(missingIdInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(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(${v.isPhDocumentOfTypeFunctionName}(missingNameInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(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(${v.isPhDocumentOfTypeFunctionName}(missingCreatedAtUtcIsoInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(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(${v.isPhDocumentOfTypeFunctionName}(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+    expect(
+      ${v.assertIsPhDocumentOfTypeFunctionName}(missingLastModifiedAtUtcIsoInHeader),
+    ).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+});
+`.raw;
+//# sourceMappingURL=document-model.test.js.map

package/dist/src/ts-morph-utils/templates/document-model/src/tests/document-model.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.js","sourceRoot":"","sources":["../../../../../../../src/ts-morph-utils/templates/document-model/src/tests/document-model.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAGhC,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAA6B,EAAE,EAAE,CAC7E,EAAE,CAAA;;;;;;;;;;;;;;;IAeA,CAAC,CAAC,wBAAwB;IAC1B,CAAC,CAAC,8BAA8B;IAChC,CAAC,CAAC,oCAAoC;IACtC,CAAC,CAAC,2BAA2B;IAC7B,CAAC,CAAC,iCAAiC;UAC7B,CAAC,CAAC,gBAAgB;;;YAGhB,CAAC,CAAC,sBAAsB;4BACR,CAAC,CAAC,sBAAsB;;;;gDAIJ,CAAC,CAAC,wBAAwB;;;4BAG9C,CAAC,CAAC,sBAAsB;;;;aAIvC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,2BAA2B;;+CAEK,CAAC,CAAC,sBAAsB;;;;eAIxD,CAAC,CAAC,oCAAoC;eACtC,CAAC,CAAC,8BAA8B;;;;;;;;;;;aAWlC,CAAC,CAAC,2BAA2B;aAC7B,CAAC,CAAC,iCAAiC;aACnC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,oCAAoC;;;;;;;;;;;aAWtC,CAAC,CAAC,2BAA2B;aAC7B,CAAC,CAAC,iCAAiC;aACnC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,oCAAoC;;;;;;;;;aAStC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,oCAAoC;;;;;;;;;aAStC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,oCAAoC;;;;;;;;;aAStC,CAAC,CAAC,8BAA8B;aAChC,CAAC,CAAC,oCAAoC;;;;;;;;;aAStC,CAAC,CAAC,8BAA8B;;QAErC,CAAC,CAAC,oCAAoC;;;;;;CAM7C,CAAC,GAAG,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/src/tests/module.test.d.ts

@@ -0,0 +1,3 @@
+import type { AllDocumentModelVariableNames } from "../../../../name-builders/types.js";
+export declare const documentModelOperationsModuleTestFileTemplate: (v: AllDocumentModelVariableNames) => string;
+//# sourceMappingURL=module.test.d.ts.map

package/dist/src/ts-morph-utils/templates/document-model/src/tests/module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.test.d.ts","sourceRoot":"","sources":["../../../../../../../src/ts-morph-utils/templates/document-model/src/tests/module.test.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,6BAA6B,EAC9B,MAAM,oCAAoC,CAAC;AAyD5C,eAAO,MAAM,6CAA6C,GACxD,GAAG,6BAA6B,WAsB7B,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/src/tests/module.test.js

@@ -0,0 +1,67 @@
+import { ts } from "@tmpl/core";
+import { camelCase, constantCase, pascalCase } from "change-case";
+function makeModuleOperationsTypeName(module) {
+    const pascalCaseModuleName = pascalCase(module.name);
+    return `${pascalCaseModuleName}Operations`;
+}
+function makeCamelCaseActionNamesForImport(actions) {
+    return actions.map((a) => camelCase(a.name)).join(",\n");
+}
+function makeActionInputSchemasForImport(actions) {
+    return actions.map((a) => `${pascalCase(a.name)}InputSchema`).join(",\n");
+}
+function makeTestCaseForAction(action, isPhDocumentOfTypeFunctionName) {
+    const camelCaseActionName = camelCase(action.name);
+    const pascalCaseActionName = pascalCase(action.name);
+    const constantCaseActionName = constantCase(action.name);
+    const actionInputSchemaName = `${pascalCaseActionName}InputSchema`;
+    const scope = action.scope;
+    return ts `
+  it('should handle ${camelCaseActionName} operation', () => {
+        const document = utils.createDocument();
+        const input = generateMock(
+            ${actionInputSchemaName}(),
+        );
+
+        const updatedDocument = reducer(
+            document,
+            ${camelCaseActionName}(input),
+        );
+
+        expect(${isPhDocumentOfTypeFunctionName}(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.${scope}).toHaveLength(1);
+        expect(updatedDocument.operations.${scope}[0].action.type).toBe(
+            "${constantCaseActionName}",
+        );
+        expect(updatedDocument.operations.${scope}[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.${scope}[0].index).toEqual(0);
+    });
+  `.raw;
+}
+function makeTestCasesForActions(actions, isPhDocumentOfTypeFunctionName) {
+    return actions
+        .map((action) => makeTestCaseForAction(action, isPhDocumentOfTypeFunctionName))
+        .join("\n\n");
+}
+export const documentModelOperationsModuleTestFileTemplate = (v) => ts `
+/**
+ * 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 { generateMock } from '@powerhousedao/codegen';
+import {
+  reducer,
+  utils,
+  ${v.isPhDocumentOfTypeFunctionName},
+  ${makeCamelCaseActionNamesForImport(v.actions)},
+  ${makeActionInputSchemasForImport(v.actions)},
+} from "${v.documentModelDir}";
+
+describe("${makeModuleOperationsTypeName(v.module)}", () => {
+  ${makeTestCasesForActions(v.actions, v.isPhDocumentOfTypeFunctionName)}
+});
+
+`.raw;
+//# sourceMappingURL=module.test.js.map

package/dist/src/ts-morph-utils/templates/document-model/src/tests/module.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.test.js","sourceRoot":"","sources":["../../../../../../../src/ts-morph-utils/templates/document-model/src/tests/module.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAOlE,SAAS,4BAA4B,CAAC,MAA2B;IAC/D,MAAM,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,OAAO,GAAG,oBAAoB,YAAY,CAAC;AAC7C,CAAC;AAED,SAAS,iCAAiC,CAAC,OAA8B;IACvE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,+BAA+B,CAAC,OAA8B;IACrE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,qBAAqB,CAC5B,MAA2B,EAC3B,8BAAsC;IAEtC,MAAM,mBAAmB,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,MAAM,sBAAsB,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzD,MAAM,qBAAqB,GAAG,GAAG,oBAAoB,aAAa,CAAC;IACnE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,OAAO,EAAE,CAAA;sBACW,mBAAmB;;;cAG3B,qBAAqB;;;;;cAKrB,mBAAmB;;;iBAGhB,8BAA8B;4CACH,KAAK;4CACL,KAAK;eAClC,sBAAsB;;4CAEO,KAAK;4CACL,KAAK;;GAE9C,CAAC,GAAG,CAAC;AACR,CAAC;AAED,SAAS,uBAAuB,CAC9B,OAA8B,EAC9B,8BAAsC;IAEtC,OAAO,OAAO;SACX,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACd,qBAAqB,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAC9D;SACA,IAAI,CAAC,MAAM,CAAC,CAAC;AAClB,CAAC;AACD,MAAM,CAAC,MAAM,6CAA6C,GAAG,CAC3D,CAAgC,EAChC,EAAE,CACF,EAAE,CAAA;;;;;;;;;;;IAWA,CAAC,CAAC,8BAA8B;IAChC,iCAAiC,CAAC,CAAC,CAAC,OAAO,CAAC;IAC5C,+BAA+B,CAAC,CAAC,CAAC,OAAO,CAAC;UACpC,CAAC,CAAC,gBAAgB;;YAEhB,4BAA4B,CAAC,CAAC,CAAC,MAAM,CAAC;IAC9C,uBAAuB,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,8BAA8B,CAAC;;;CAGvE,CAAC,GAAG,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const documentModelSrcUtilsTemplate: string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/ts-morph-utils/templates/document-model/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/ts-morph-utils/templates/document-model/src/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,6BAA6B,QAErC,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/src/utils.js

@@ -0,0 +1,5 @@
+import { ts } from "@tmpl/core";
+export const documentModelSrcUtilsTemplate = ts `
+export {};
+`.raw;
+//# sourceMappingURL=utils.js.map

package/dist/src/ts-morph-utils/templates/document-model/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../src/ts-morph-utils/templates/document-model/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEhC,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,CAAA;;CAE9C,CAAC,GAAG,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/utils.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentModelVariableNames } from "../../name-builders/types.js";
+export declare const documentModelUtilsTemplate: ({ phStateName, pascalCaseDocumentType, }: DocumentModelVariableNames) => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/ts-morph-utils/templates/document-model/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/ts-morph-utils/templates/document-model/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE/E,eAAO,MAAM,0BAA0B,GAAI,0CAGxC,0BAA0B,WASxB,CAAC"}

package/dist/src/ts-morph-utils/templates/document-model/utils.js

@@ -0,0 +1,11 @@
+import { ts } from "@tmpl/core";
+export const documentModelUtilsTemplate = ({ phStateName, pascalCaseDocumentType, }) => ts `
+import type { DocumentModelUtils } from "document-model";
+import type { ${phStateName} } from "./gen/types.js";
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+
+/** Utils for the ${pascalCaseDocumentType} document model */
+export const utils = { ...genUtils, ...customUtils } satisfies DocumentModelUtils<${phStateName}>;
+`.raw;
+//# sourceMappingURL=utils.js.map

package/dist/src/ts-morph-utils/templates/document-model/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../src/ts-morph-utils/templates/document-model/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAGhC,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,EACzC,WAAW,EACX,sBAAsB,GACK,EAAE,EAAE,CAC/B,EAAE,CAAA;;gBAEY,WAAW;;;;oBAIP,sBAAsB;oFAC0C,WAAW;CAC9F,CAAC,GAAG,CAAC"}

package/dist/src/ts-morph-utils/templates/drive-editor.d.ts

@@ -0,0 +1,5 @@
+export declare const driveExplorerFileTemplate: string;
+export declare const folderTreeFileTemplate: string;
+export declare const emptyStateFileTemplate: string;
+export declare const createDocumentFileTemplate: string;
+//# sourceMappingURL=drive-editor.d.ts.map

package/dist/src/ts-morph-utils/templates/drive-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive-editor.d.ts","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/drive-editor.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,QA6BjC,CAAC;AAEN,eAAO,MAAM,sBAAsB,QAyG9B,CAAC;AAEN,eAAO,MAAM,sBAAsB,QAgB9B,CAAC;AAEN,eAAO,MAAM,0BAA0B,QAuDlC,CAAC"}

package/dist/src/ts-morph-utils/templates/drive-editor.js

@@ -0,0 +1,211 @@
+import { tsx } from "@tmpl/core";
+export const driveExplorerFileTemplate = tsx `
+import type { EditorProps } from "document-model";
+import { FolderTree } from "./FolderTree.js";
+import { DriveContents } from "./DriveContents.js";
+
+/**
+ * Main drive explorer component with sidebar navigation and content area.
+ * Layout: Left sidebar (folder tree) + Right content area (files/folders + document editor)
+ */
+export function DriveExplorer({ children }: EditorProps) {
+  // if a document is selected then it's editor will be passed as children
+  const showDocumentEditor = !!children;
+
+  return (
+    <div className="flex h-full">
+      <FolderTree />
+      <div className="flex-1 overflow-y-auto p-4">
+        {/* Conditional rendering: Document editor or folder contents */}
+        {showDocumentEditor ? (
+          /* Document editor view */
+          children
+        ) : (
+          /* Folder contents view */
+          <DriveContents />
+        )}
+      </div>
+    </div>
+  );
+}
+`.raw;
+export const folderTreeFileTemplate = tsx `
+  import {
+  Sidebar,
+  SidebarProvider,
+  type SidebarNode,
+} from "@powerhousedao/document-engineering";
+import {
+  setSelectedNode,
+  useNodesInSelectedDrive,
+  useSelectedDrive,
+  useSelectedNode,
+} from "@powerhousedao/reactor-browser";
+import type { Node } from "document-drive";
+import { useMemo } from "react";
+
+function buildSidebarNodes(
+  nodes: Node[],
+  parentId: string | null | undefined,
+): SidebarNode[] {
+  return nodes
+    .filter((n) => {
+      if (parentId == null) {
+        return n.parentFolder == null;
+      }
+      return n.parentFolder === parentId;
+    })
+    .map((node): SidebarNode => {
+      if (node.kind === "folder") {
+        return {
+          id: node.id,
+          title: node.name,
+          icon: "FolderClose" as const,
+          expandedIcon: "FolderOpen" as const,
+          children: buildSidebarNodes(nodes, node.id),
+        };
+      }
+      return {
+        id: node.id,
+        title: node.name,
+        icon: "File" as const,
+      };
+    });
+}
+
+function transformNodesToSidebarNodes(
+  nodes: Node[],
+  driveName: string,
+): SidebarNode[] {
+  return [
+    {
+      id: "root",
+      title: driveName,
+      icon: "Drive" as const,
+      children: buildSidebarNodes(nodes, null),
+    },
+  ];
+}
+
+/**
+ * Hierarchical folder tree navigation component using Sidebar from document-engineering.
+ * Displays folders and files in a tree structure with expand/collapse functionality, search, and resize support.
+ */
+export function FolderTree() {
+  const [selectedDrive] = useSelectedDrive();
+  const nodes = useNodesInSelectedDrive();
+  const selectedNode = useSelectedNode();
+  const driveName = selectedDrive.header.name;
+  // Transform Node[] to hierarchical SidebarNode structure
+  const sidebarNodes = useMemo(
+    () => transformNodesToSidebarNodes(nodes || [], driveName),
+    [nodes, driveName],
+  );
+
+  const handleActiveNodeChange = (node: SidebarNode) => {
+    // If root node is selected, pass undefined to match existing behavior
+    if (node.id === "root") {
+      setSelectedNode(undefined);
+    } else {
+      setSelectedNode(node.id);
+    }
+  };
+  // Map selectedNodeId to activeNodeId (use "root" when undefined)
+  const activeNodeId =
+    !selectedNode || selectedNode.id === selectedDrive.header.id
+      ? "root"
+      : selectedNode.id;
+
+  return (
+    <SidebarProvider nodes={sidebarNodes}>
+      <Sidebar
+        className="pt-1"
+        nodes={sidebarNodes}
+        activeNodeId={activeNodeId}
+        onActiveNodeChange={handleActiveNodeChange}
+        sidebarTitle="Drive Explorer"
+        showSearchBar={true}
+        resizable={true}
+        allowPinning={false}
+        showStatusFilter={false}
+        initialWidth={256}
+        defaultLevel={2}
+      />
+    </SidebarProvider>
+  );
+}
+`.raw;
+export const emptyStateFileTemplate = tsx `
+import { useNodesInSelectedDriveOrFolder } from "@powerhousedao/reactor-browser";
+
+/** Shows a message when the selected drive or folder is empty */
+export function EmptyState() {
+  const nodes = useNodesInSelectedDriveOrFolder();
+  const hasNodes = nodes.length > 0;
+  if (hasNodes) return null;
+
+  return (
+    <div className="py-12 text-center text-gray-500">
+      <p className="text-lg">This folder is empty</p>
+      <p className="mt-2 text-sm">Create your first document or folder below</p>
+    </div>
+  );
+}
+`.raw;
+export const createDocumentFileTemplate = tsx `
+import type { VetraDocumentModelModule } from "@powerhousedao/reactor-browser";
+import {
+  showCreateDocumentModal,
+  useAllowedDocumentModelModules,
+} from "@powerhousedao/reactor-browser";
+
+/**
+ * Document creation UI component.
+ * Displays available document types as clickable buttons.
+ */
+export function CreateDocument() {
+  const allowedDocumentModelModules = useAllowedDocumentModelModules();
+
+  return (
+    <div>
+      {/* Customize section title here */}
+      <h3 className="mb-3 mt-4 text-sm font-bold text-gray-600">
+        Create document
+      </h3>
+      {/* Customize layout by changing flex-wrap, gap, or grid layout */}
+      <div className="flex w-full flex-wrap gap-4">
+        {allowedDocumentModelModules?.map((documentModelModule) => {
+          return (
+            <CreateDocumentButton
+              key={documentModelModule.documentModel.global.id}
+              documentModelModule={documentModelModule}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+type Props = {
+  documentModelModule: VetraDocumentModelModule;
+};
+function CreateDocumentButton({ documentModelModule }: Props) {
+  const documentType = documentModelModule.documentModel.global.id;
+  const documentModelName =
+    documentModelModule.documentModel.global.name || documentType;
+  const documentModelDescription =
+    documentModelModule.documentModel.global.description;
+  return (
+    <button
+      className="cursor-pointer rounded-md bg-gray-200 py-2 px-3 hover:bg-gray-300"
+      title={documentModelName}
+      aria-description={documentModelDescription}
+      onClick={() => showCreateDocumentModal(documentType)}
+    >
+      {documentModelName}
+    </button>
+  );
+}
+`.raw;
+//# sourceMappingURL=drive-editor.js.map

package/dist/src/ts-morph-utils/templates/drive-editor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive-editor.js","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/drive-editor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEjC,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B3C,CAAC,GAAG,CAAC;AAEN,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGxC,CAAC,GAAG,CAAC;AAEN,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;CAgBxC,CAAC,GAAG,CAAC;AAEN,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuD5C,CAAC,GAAG,CAAC"}

package/dist/src/ts-morph-utils/templates/unsafe-utils.d.ts

@@ -0,0 +1,8 @@
+export declare function getInitialStates(scopeState: {
+    global: any;
+    local: any;
+}): {
+    initialGlobalState: string;
+    initialLocalState: string;
+};
+//# sourceMappingURL=unsafe-utils.d.ts.map

package/dist/src/ts-morph-utils/templates/unsafe-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-utils.d.ts","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/unsafe-utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,gBAAgB,CAAC,UAAU,EAAE;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE;;;EAkBvE"}

package/dist/src/ts-morph-utils/templates/unsafe-utils.js

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+export function getInitialStates(scopeState) {
+    const { global, local } = scopeState;
+    const scopes = { global, local };
+    Object.entries(scopes).forEach(([scope, state]) => {
+        if (!isEmptyStateSchema(state.schema) && state.initialValue === "") {
+            throw new Error(`${scope.charAt(0).toLocaleUpperCase() + scope.slice(1)} scope has a defined schema but is missing an initial value.`);
+        }
+    });
+    return {
+        initialGlobalState: handleEmptyState(global.initialValue),
+        initialLocalState: handleEmptyState(local.initialValue),
+    };
+}
+function isEmptyStateSchema(schema) {
+    return schema === "" || !schema.includes("{");
+}
+function handleEmptyState(state) {
+    return state === "" ? "{}" : state;
+}
+//# sourceMappingURL=unsafe-utils.js.map

package/dist/src/ts-morph-utils/templates/unsafe-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-utils.js","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/unsafe-utils.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,+DAA+D;AAC/D,0DAA0D;AAC1D,MAAM,UAAU,gBAAgB,CAAC,UAAuC;IACtE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IACrC,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAEjC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE;QAChD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,YAAY,KAAK,EAAE,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CACb,GACE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CACrD,8DAA8D,CAC/D,CAAC;QACJ,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,kBAAkB,EAAE,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC;QACzD,iBAAiB,EAAE,gBAAgB,CAAC,KAAK,CAAC,YAAY,CAAC;KACxD,CAAC;AACJ,CAAC;AAED,SAAS,kBAAkB,CAAC,MAAyB;IACnD,OAAO,MAAM,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAChD,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAa;IACrC,OAAO,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AACrC,CAAC"}

package/dist/src/ts-morph-utils/templates/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ActionFromOperation } from "../name-builders/types.js";
+export declare function getActionTypeName(action: ActionFromOperation): string;
+export declare function getActionInputName(action: ActionFromOperation): string | undefined;
+export declare function getActionType(action: ActionFromOperation): string;
+export declare function getActionInputTypeNames(actions: ActionFromOperation[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/ts-morph-utils/templates/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,UAE5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,sBAG7D;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,UAExD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,mBAAmB,EAAE,UAErE"}

package/dist/src/ts-morph-utils/templates/utils.js

@@ -0,0 +1,16 @@
+import { constantCase, pascalCase } from "change-case";
+export function getActionTypeName(action) {
+    return `${pascalCase(action.name)}Action`;
+}
+export function getActionInputName(action) {
+    if (!action.hasInput)
+        return;
+    return `${pascalCase(action.name)}Input`;
+}
+export function getActionType(action) {
+    return constantCase(action.name);
+}
+export function getActionInputTypeNames(actions) {
+    return actions.map(getActionInputName).join(",\n");
+}
+//# sourceMappingURL=utils.js.map

package/dist/src/ts-morph-utils/templates/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/ts-morph-utils/templates/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGvD,MAAM,UAAU,iBAAiB,CAAC,MAA2B;IAC3D,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,MAA2B;IAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ;QAAE,OAAO;IAC7B,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,MAA2B;IACvD,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,OAA8B;IACpE,OAAO,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACrD,CAAC"}

package/dist/src/ts-morph-utils/ts-morph-project.d.ts

@@ -0,0 +1,3 @@
+import { Project } from "ts-morph";
+export declare function buildTsMorphProject(projectDir: string): Project;
+//# sourceMappingURL=ts-morph-project.d.ts.map

package/dist/src/ts-morph-utils/ts-morph-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-project.d.ts","sourceRoot":"","sources":["../../../src/ts-morph-utils/ts-morph-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAInC,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,WAIrD"}

package/dist/src/ts-morph-utils/ts-morph-project.js

@@ -0,0 +1,9 @@
+import { Project } from "ts-morph";
+import { getDefaultProjectOptions } from "./file-utils.js";
+import { buildTsConfigFilePath } from "./name-builders/common-files.js";
+export function buildTsMorphProject(projectDir) {
+    const tsConfigFilePath = buildTsConfigFilePath(projectDir);
+    const project = new Project(getDefaultProjectOptions(tsConfigFilePath));
+    return project;
+}
+//# sourceMappingURL=ts-morph-project.js.map

package/dist/src/ts-morph-utils/ts-morph-project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-project.js","sourceRoot":"","sources":["../../../src/ts-morph-utils/ts-morph-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,MAAM,UAAU,mBAAmB,CAAC,UAAkB;IACpD,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC3D,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACxE,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/src/ts-morph-utils/types.d.ts

@@ -0,0 +1,34 @@
+export type DocumentModelDocumentTypeMetadata = {
+    documentModelId: string;
+    documentModelDocumentTypeName: string;
+    documentModelDirName: string;
+    documentModelImportPath: string;
+};
+export type DocumentModelFilePaths = {
+    documentModelsSourceFilesPath: string;
+    documentModelsDirPath: string;
+};
+export type EditorFilePaths = {
+    editorSourceFilesPath: string;
+    editorsDirPath: string;
+    editorFilePath: string;
+    editorModuleFilePath: string;
+    editDocumentNameComponentFilePath: string;
+    editorConfigFilePath: string;
+    driveContentsFilePath: string;
+    editorComponentsDirPath: string;
+};
+export type EditorVariableNames = {
+    documentVariableName: string;
+    editDocumentNameComponentName: string;
+    useSelectedDocumentHookName: string;
+    documentNameVariableName: string;
+    dispatchFunctionName: string;
+    onClickEditHandlerName: string;
+    onCancelEditHandlerName: string;
+    setNameActionName: string;
+    isEditingVariableName: string;
+    setIsEditingFunctionName: string;
+    onSubmitSetNameFunctionName: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/ts-morph-utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ts-morph-utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iCAAiC,GAAG;IAC9C,eAAe,EAAE,MAAM,CAAC;IACxB,6BAA6B,EAAE,MAAM,CAAC;IACtC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,6BAA6B,EAAE,MAAM,CAAC;IACtC,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iCAAiC,EAAE,MAAM,CAAC;IAC1C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,6BAA6B,EAAE,MAAM,CAAC;IACtC,2BAA2B,EAAE,MAAM,CAAC;IACpC,wBAAwB,EAAE,MAAM,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,wBAAwB,EAAE,MAAM,CAAC;IACjC,2BAA2B,EAAE,MAAM,CAAC;CACrC,CAAC"}

package/dist/src/ts-morph-utils/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/ts-morph-utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/ts-morph-utils/types.ts"],"names":[],"mappings":""}