@powerhousedao/codegen 6.0.0-dev.109 → 6.0.0-dev.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/codegen",
-  "version": "6.0.0-dev.109",
+  "version": "6.0.0-dev.110",
   "license": "AGPL-3.0-only",
   "private": false,
   "type": "module",
@@ -43,21 +43,18 @@
     "arg": "^5.0.2",
     "chalk": "5.6.2",
     "change-case": "5.4.4",
-    "enquirer": "2.4.1",
-    "execa": "^8.0.1",
     "graphql": "16.12.0",
     "graphql-codegen-typescript-validation-schema": "0.18.1",
-    "hygen": "^6.2.11",
     "package-json-validator": "^0.60.0",
     "prettier": "3.8.1",
     "read-pkg": "10.1.0",
     "semver": "7.7.4",
     "ts-morph": "27.0.2",
     "zocker": "^3.0.0",
-    "@powerhousedao/config": "6.0.0-dev.109",
-    "@powerhousedao/shared": "6.0.0-dev.109",
-    "@powerhousedao/common": "6.0.0-dev.109",
-    "document-model": "6.0.0-dev.109"
+    "@powerhousedao/config": "6.0.0-dev.110",
+    "document-model": "6.0.0-dev.110",
+    "@powerhousedao/shared": "6.0.0-dev.110",
+    "@powerhousedao/common": "6.0.0-dev.110"
   },
   "devDependencies": {
     "@types/bun": "1.3.8",
@@ -68,25 +65,19 @@
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4",
     "zod": "4.3.6",
-    "@powerhousedao/analytics-engine-core": "6.0.0-dev.109",
-    "@powerhousedao/design-system": "6.0.0-dev.109",
-    "@powerhousedao/reactor-browser": "6.0.0-dev.109",
-    "document-drive": "6.0.0-dev.109"
+    "@powerhousedao/analytics-engine-core": "6.0.0-dev.110",
+    "@powerhousedao/design-system": "6.0.0-dev.110",
+    "@powerhousedao/reactor-browser": "6.0.0-dev.110"
   },
   "scripts": {
     "tsc": "tsc",
     "lint": "eslint",
-    "copy-hygen": "rm -rf dist/src/codegen/.hygen && cp -r src/codegen/.hygen dist/src/codegen/",
-    "build:misc": "pnpm copy-hygen",
     "build:create-lib": "tsc --project src/create-lib/tsconfig.json",
     "publish:create-lib": "npm publish --cwd ./src/create-lib/",
     "start": "tsx src/cli.ts",
-    "pretest": "pnpm build:misc",
     "test:bun": "bun test --concurrent --timeout 1000000",
     "test:vitest": "vitest --run",
     "test": "pnpm test:bun generate-doc-model.test.ts generate-processor.test.ts && pnpm test:vitest",
-    "test:keep": "KEEP_TEST_OUTPUT=true pnpm test",
-    "test:hygen": "USE_TS_MORPH=false pnpm test",
-    "test:keep:hygen": "USE_TS_MORPH=false KEEP_TEST_OUTPUT=true pnpm test"
+    "test:keep": "KEEP_TEST_OUTPUT=true pnpm test"
   }
 }

package/dist/src/codegen/.hygen/package.json

@@ -1,6 +0,0 @@
-{
-  "type": "commonjs",
-  "files": [
-    "*"
-  ]
-}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-custom-subgraph/index.js

@@ -1,10 +0,0 @@
-// @ts-check
-const generateCustomSubgraph = {
-  params: ({ args }) => {
-    return {
-      rootDir: args.rootDir,
-      subgraph: args.subgraph,
-    };
-  },
-};
-module.exports = generateCustomSubgraph;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-custom-subgraph/schema.esm.t

@@ -1,20 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/schema.ts"
-unless_exists: true
----
-import { gql } from "graphql-tag";
-import type { DocumentNode } from "graphql";
-
-export const schema: DocumentNode = gql`
-"""
-<%= h.changeCase.pascal(subgraph) %> Queries
-"""
-type <%= h.changeCase.pascal(subgraph) %>Queries {
-    example(driveId: String!): String
-}
-
-type Query {
-    <%= h.changeCase.camel(subgraph) %>: <%= h.changeCase.pascal(subgraph) %>Queries!
-}
-
-`

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/actions.esm.t

@@ -1,16 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/actions.ts"
-force: true
----
-<% modules.forEach(module => { _%>
-import type { <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module.name) %>Action } from './<%= h.changeCase.param(module.name) %>/actions.js';
-<% }); _%>
-
-<% modules.forEach(module => { _%>
-export * from './<%= h.changeCase.param(module.name) %>/actions.js';
-<% }); _%>
-
-export <%= 'type ' + h.changeCase.pascal(documentType) %>Action =
-<% modules.forEach(module => { _%>
-    | <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module.name) %>Action
-<% }); _%>;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/creators.esm.t

@@ -1,9 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/creators.ts"
-force: true
----
-
-<% modules.forEach(module => { _%>
-export * from "./<%= h.changeCase.param(module.name) %>/creators.js";
-export * as <%= h.changeCase.camel(module.name) %>Actions from "./<%= h.changeCase.param(module.name) %>/creators.js";
-<% }); _%>

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/customUtils.esm.t

@@ -1,5 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/utils.ts"
-unless_exists: true
----
-export {};

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/document-schema.esm.t

@@ -1,56 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-schema.ts"
-force: true
----
-import {
-  BaseDocumentHeaderSchema,
-  BaseDocumentStateSchema,
-} from "document-model";
-import { z } from "zod";
-import { <%= documentTypeVariableName %> } from "./document-type.js";
-import { <%= stateSchemaName %> } from "./schema/zod.js";
-import type { <%= phDocumentTypeName %>, <%= phStateName %> } from "./types.js";
-
-/** Schema for validating the header object of a <%= pascalCaseDocumentType %> document */
-export const <%= phDocumentTypeName %>HeaderSchema = BaseDocumentHeaderSchema.extend({
-  documentType: z.literal(<%= documentTypeVariableName %>),
-});
-
-/** Schema for validating the state object of a <%= pascalCaseDocumentType %> document */
-export const <%= phStateName %>Schema = BaseDocumentStateSchema.extend({
-  global: <%= stateSchemaName %>(),
-});
-
-export const <%= phDocumentSchemaName %> = z.object({
-  header: <%= phDocumentTypeName %>HeaderSchema,
-  state: <%= phStateName %>Schema,
-  initialState: <%= phStateName %>Schema,
-});
-
-/** Simple helper function to check if a state object is a <%= pascalCaseDocumentType %> document state object */
-export function <%= isPhStateOfTypeFunctionName %>(
-  state: unknown,
-): state is <%= phStateName %> {
-  return <%= phStateName %>Schema.safeParse(state).success;
-}
-
-/** Simple helper function to assert that a document state object is a <%= pascalCaseDocumentType %> document state object */
-export function <%= assertIsPhStateOfTypeFunctionName %>(
-  state: unknown,
-): asserts state is <%= phStateName %> {
-  <%= phStateName %>Schema.parse(state);
-}
-
-/** Simple helper function to check if a document is a <%= pascalCaseDocumentType %> document */
-export function <%= isPhDocumentOfTypeFunctionName %>(
-  document: unknown,
-): document is <%= phDocumentTypeName %> {
-  return <%= phDocumentSchemaName %>.safeParse(document).success;
-}
-
-/** Simple helper function to assert that a document is a <%= pascalCaseDocumentType %> document */
-export function <%= assertIsPhDocumentOfTypeFunctionName %>(
-  document: unknown,
-): asserts document is <%= phDocumentTypeName %> {
-  <%= phDocumentSchemaName %>.parse(document);
-}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/document-type.esm.t

@@ -1,6 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-type.ts"
-force: true
----
-
-export const <%= documentTypeVariableName %> = "<%= documentTypeId %>";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/documentModel.esm.t

@@ -1,7 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-model.ts"
-force: true
----
-import type { DocumentModelGlobalState } from "document-model";
-
-export const documentModel: DocumentModelGlobalState = <%- documentModel %>;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/documentModelTest.esm.t

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

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/hooks.esm.t

@@ -1,49 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/hooks.ts"
-force: true
----
-
-import type { DocumentDispatch } from "@powerhousedao/reactor-browser";
-import {
-  useDocumentsInSelectedDrive,
-  useDocumentsInSelectedFolder,
-  useDocumentById,
-  useSelectedDocument,
-} from "@powerhousedao/reactor-browser";
-import type {
-  <%= phDocumentTypeName %>,
-  <%= actionTypeName %>,
-} from "<%= documentModelDir %>";
-import { <%= isPhDocumentOfTypeFunctionName %> } from "./gen/document-schema.js";
-
-/** Hook to get a <%= pascalCaseDocumentType %> document by its id */
-export function <%= useByIdHookName %>(
-  documentId: string | null | undefined,
-):
-  | [<%= phDocumentTypeName %>, DocumentDispatch<<%= actionTypeName %>>]
-  | [undefined, undefined] {
-  const [document, dispatch] = useDocumentById(documentId);
-  if (!<%= isPhDocumentOfTypeFunctionName %>(document)) return [undefined, undefined];
-  return [document, dispatch];
-}
-
-/** Hook to get the selected <%= pascalCaseDocumentType %> document */
-export function <%= useSelectedHookName %>():
-  | [<%= phDocumentTypeName %>, DocumentDispatch<<%= actionTypeName %>>]
-  | [undefined, undefined] {
-  const [document, dispatch] = useSelectedDocument();
-  if (!<%= isPhDocumentOfTypeFunctionName %>(document)) return [undefined, undefined];
-  return [document, dispatch];
-}
-
-/** Hook to get all <%= pascalCaseDocumentType %> documents in the selected drive */
-export function <%= useInSelectedDriveHookName %>() {
-  const documentsInSelectedDrive = useDocumentsInSelectedDrive();
-  return documentsInSelectedDrive?.filter(<%= isPhDocumentOfTypeFunctionName %>);
-}
-
-/** Hook to get all <%= pascalCaseDocumentType %> documents in the selected folder */
-export function <%= useInSelectedFolderHookName %>() {
-  const documentsInSelectedFolder = useDocumentsInSelectedFolder();
-  return documentsInSelectedFolder?.filter(<%= isPhDocumentOfTypeFunctionName %>);
-}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/index.esm.t

@@ -1,23 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/index.ts"
-force: true
----
-export * from './actions.js';
-export * from './document-model.js';
-export * from './types.js';
-export * from './creators.js';
-export {
-  create<%= phDocumentTypeName %>,
-  createState,
-  defaultPHState,
-  defaultGlobalState,
-  defaultLocalState,
-} from './ph-factories.js';
-export * from "./utils.js";
-export * from "./reducer.js";
-export * from "./schema/index.js";
-export * from "./document-type.js";
-export * from "./document-schema.js";
-<% modules.forEach(module => { _%>
-export * from './<%= h.changeCase.param(module.name) %>/operations.js';
-<% }); _%>

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/index.js

@@ -1,127 +0,0 @@
-// @ts-check
-const { kebabCase, pascalCase, camelCase } = require("change-case");
-function documentModelToString(documentModel) {
-  return JSON.stringify(
-    {
-      ...documentModel,
-      specifications: documentModel.specifications.map((s) => ({
-        ...s,
-        state: Object.keys(s.state).reduce((values, scope) => {
-          const state = s.state[scope];
-          return {
-            ...values,
-            [scope]: {
-              ...state,
-              // initial value has to be stringified twice
-              // as it is expected to be a string
-              initialValue: JSON.stringify(state.initialValue),
-            },
-          };
-        }, {}),
-      })),
-    },
-    null,
-    2,
-  );
-}
-
-module.exports = {
-  params: ({ args }) => {
-    const documentModel = JSON.parse(args.documentModel);
-    const latestSpec =
-      documentModel.specifications[documentModel.specifications.length - 1];
-    const documentType = documentModel.name;
-    const documentTypeId = documentModel.id;
-    const rootDir = args.rootDir;
-    const kebabCaseDocumentType = kebabCase(documentType);
-    const pascalCaseDocumentType = pascalCase(documentType);
-    const camelCaseDocumentType = camelCase(documentType);
-    const documentTypeVariableName = `${camelCaseDocumentType}DocumentType`;
-    const stateName = `${pascalCaseDocumentType}State`;
-    const globalStateName = `${pascalCaseDocumentType}GlobalState`;
-    const localStateName = `${pascalCaseDocumentType}LocalState`;
-    const phStateName = `${pascalCaseDocumentType}PHState`;
-    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
-    const actionTypeName = `${pascalCaseDocumentType}Action`;
-    const actionsTypeName = `${actionTypeName}s`;
-    const actionsName = camelCase(actionsTypeName);
-    const packageName = args.packageName;
-    const documentModelDir = `${packageName}/document-models/${kebabCaseDocumentType}`;
-    const stateSchemaName = `${stateName}Schema`;
-    const phDocumentSchemaName = `${phDocumentTypeName}Schema`;
-    const isPhStateOfTypeFunctionName = `is${stateName}`;
-    const assertIsPhStateOfTypeFunctionName = `assertIs${stateName}`;
-    const isPhDocumentOfTypeFunctionName = `is${phDocumentTypeName}`;
-    const assertIsPhDocumentOfTypeFunctionName = `assertIs${phDocumentTypeName}`;
-    const useByIdHookName = `use${phDocumentTypeName}ById`;
-    const useSelectedHookName = `useSelected${phDocumentTypeName}`;
-    const useInSelectedDriveHookName = `use${phDocumentTypeName}sInSelectedDrive`;
-    const useInSelectedFolderHookName = `use${phDocumentTypeName}sInSelectedFolder`;
-    return {
-      rootDir,
-      packageName,
-      useByIdHookName,
-      useSelectedHookName,
-      useInSelectedDriveHookName,
-      useInSelectedFolderHookName,
-      documentModel: documentModelToString(documentModel),
-      documentTypeVariableName,
-      documentTypeId,
-      documentType,
-      camelCaseDocumentType,
-      kebabCaseDocumentType,
-      pascalCaseDocumentType,
-      stateName,
-      globalStateName,
-      localStateName,
-      phDocumentTypeName,
-      phStateName,
-      actionTypeName,
-      actionsTypeName,
-      actionsName,
-      stateSchemaName,
-      phDocumentSchemaName,
-      isPhDocumentOfTypeFunctionName,
-      assertIsPhDocumentOfTypeFunctionName,
-      isPhStateOfTypeFunctionName,
-      assertIsPhStateOfTypeFunctionName,
-      documentModelDir,
-      extension: documentModel.extension,
-      modules: latestSpec.modules.map((m) => ({
-        ...m,
-        name: kebabCase(m.name),
-      })),
-      fileExtension: documentModel.extension || "",
-      hasLocalSchema: latestSpec.state.local.schema !== "",
-      ...getInitialStates(latestSpec.state),
-    };
-  },
-};
-
-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;
-}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/module.esm.t

@@ -1,22 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/module.ts"
-force: true
----
-import type { DocumentModelModule } from "document-model";
-import { createState } from "document-model";
-import { defaultBaseState } from "document-model/core";
-import type { <%= phStateName %> } from "<%= documentModelDir %>";
-import {
-  actions,
-  documentModel,
-  reducer,
-  utils,
-} from "<%= documentModelDir %>";
-
-/** Document model module for the <%= pascalCaseDocumentType %> document type */
-export const <%= pascalCaseDocumentType %>: DocumentModelModule<<%= phStateName %>> = {
-  reducer,
-  actions,
-  utils,
-  documentModel: createState(defaultBaseState(), documentModel),
-};

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/ph-factories.esm.t

@@ -1,93 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/ph-factories.ts"
-force: true
----
-/**
- * Factory methods for creating <%= phDocumentTypeName %> instances
- */
-import type {
-  PHAuthState,
-  PHDocumentState,
-  PHBaseState,
-} from "document-model";
-import {
-  createBaseState,
-  defaultBaseState,
-} from "document-model/core";
-import type {
-  <%= phDocumentTypeName %>,
-  <%= localStateName %>,
-  <%= globalStateName %>,
-  <%= phStateName %>,
-} from "./types.js";
-import { createDocument } from "./utils.js";
-
-export function defaultGlobalState(): <%= globalStateName %> {
-  return <%- initialGlobalState %>;
-}
-
-export function defaultLocalState(): <%= localStateName %> {
-  return <%- initialLocalState %>;
-}
-
-export function defaultPHState(): <%= phStateName %> {
-  return {
-    ...defaultBaseState(),
-    global: defaultGlobalState(),
-    local: defaultLocalState(),
-  };
-}
-
-export function createGlobalState(
-  state?: Partial<<%= globalStateName %>>,
-): <%= globalStateName %> {
-  return {
-    ...defaultGlobalState(),
-    ...(state || {}),
-  } as <%= globalStateName %>;
-}
-
-export function createLocalState(
-  state?: Partial<<%= localStateName %>>,
-): <%= localStateName %> {
-  return {
-    ...defaultLocalState(),
-    ...(state || {}),
-  } as <%= localStateName %>;
-}
-
-export function createState(
-  baseState?: Partial<PHBaseState>,
-  globalState?: Partial<<%= globalStateName %>>,
-  localState?: Partial<<%= localStateName %>>,
-): <%= phStateName %> {
-  return {
-    ...createBaseState(baseState?.auth, baseState?.document),
-    global: createGlobalState(globalState),
-    local: createLocalState(localState),
-  };
-}
-
-/**
- * Creates a <%= phDocumentTypeName %> with custom global and local state
- * This properly handles the PHBaseState requirements while allowing
- * document-specific state to be set.
- */
-export function create<%= phDocumentTypeName %>(
-  state?: Partial<{
-    auth?: Partial<PHAuthState>;
-    document?: Partial<PHDocumentState>;
-    global?: Partial<<%= globalStateName %>>;
-    local?: Partial<<%= localStateName %>>;
-  }>,
-): <%= phDocumentTypeName %> {
-  const document = createDocument(
-    state ? createState(
-      createBaseState(state.auth, state.document),
-      state.global,
-      state.local,
-    ) : undefined
-  );
-
-  return document;
-}