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

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

@@ -0,0 +1,93 @@
+---
+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;
+}

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

@@ -1,15 +1,27 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/reducer.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/reducer.ts"
 force: true
 ---
-import { type StateReducer, isDocumentAction, createReducer } from "document-model";
-import { <%= 'type ' + h.changeCase.pascal(documentType) %>Document, z } from './types.js';
+// TODO: remove eslint-disable rules once refactor is done
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import type { StateReducer } from "document-model";
+import { isDocumentAction, createReducer } from "document-model/core";
+import type { <%= phStateName %> } from "<%= documentModelDir %>";
 
-<% modules.forEach(m => { _%>
-import { reducer as <%= h.changeCase.pascal(m.name) %>Reducer } from '../src/reducers/<%= h.changeCase.param(m.name) %>.js';
+<% modules.forEach(module => { _%>
+import { <%= camelCaseDocumentType %><%= h.changeCase.pascal(module.name) %>Operations } from "../src/reducers/<%= h.changeCase.param(module.name) %>.js";
 <%_ }); %>
 
-const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>Document> =
+<% const schemas = modules.flatMap(m =>
+     m.operations.map(o => `${h.changeCase.pascalCase(o.name)}InputSchema`)
+   );
+%>
+import {
+  <%= schemas.join(',\n  ') %>
+} from "./schema/zod.js";
+
+const stateReducer: StateReducer<<%= phStateName %>> =
     (state, action, dispatch) => {
         if (isDocumentAction(action)) {
             return state;
@@ -20,9 +32,9 @@ const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>Documen
     modules.map(m => m.operations.map(o => 
         '            case "' + h.changeCase.constant(o.name) + '":\n' + 
         '                ' + (o.schema !== null ? 
-            'z.' + h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
+            h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
             'if (Object.keys(action.input).length > 0) throw new Error("Expected empty input for action ' + h.changeCase.constant(o.name) + '");\n') +
-        '                ' + h.changeCase.pascal(m.name) + 'Reducer.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
+        '                ' + camelCaseDocumentType + h.changeCase.pascal(m.name)  + 'Operations.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
         '                break;\n'        
     ).join('\n')).join('\n')
 %>
@@ -31,4 +43,4 @@ const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>Documen
         }
     }
 
-export const reducer = createReducer<<%= h.changeCase.pascal(documentType) %>Document>(stateReducer);
+export const reducer = createReducer<<%= phStateName %>>(stateReducer);

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

@@ -0,0 +1,11 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/utils.ts"
+force: true
+---
+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 %>>;

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

@@ -0,0 +1,13 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/actions.ts"
+force: true
+---
+import { baseActions } from "document-model";
+import { <% modules.forEach(module => { _%>
+<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%>  } from "./gen/creators.js";
+
+/** Actions for the <%= pascalCaseDocumentType %> document model */
+export const actions = { ...baseActions, <% modules.forEach(module => { _%>
+   ...<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%> };

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

@@ -1,5 +1,5 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/index.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/index.ts"
 force: true
 ---
 /**
@@ -7,29 +7,8 @@ force: true
  * Delete the file and run the code generator again to have it reset
  */
 
-import { actions as BaseActions, type DocumentModelModule } from 'document-model';
-import { actions as <%= h.changeCase.pascal(documentType) %>Actions } from './gen/index.js';
-import { reducer } from './gen/reducer.js';
-import { documentModel } from './gen/document-model.js';
-import genUtils from './gen/utils.js';
-import * as customUtils from './src/utils.js';
-import {
-    <%= 'type ' + h.changeCase.pascal(documentType) %>Document,
-} from './gen/types.js';
-
-const utils = { ...genUtils, ...customUtils };
-const actions = { ...BaseActions, ...<%= h.changeCase.pascal(documentType) %>Actions };
-
-export const module: DocumentModelModule<
-    <%= h.changeCase.pascal(documentType) %>Document
-> = {
-    reducer,
-    actions,
-    utils,
-    documentModel,
-};
-
-export { reducer, actions, utils, documentModel };
-
-export * from './gen/types.js';
-export * from './src/utils.js';
+export * from "./gen/index.js";
+export * from "./src/index.js";
+export * from "./hooks.js";
+export { actions } from "./actions.js";
+export { utils } from "./utils.js";

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

@@ -1,6 +1,6 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/schema/index.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/schema/index.ts"
 force: true
 ---
 export * from "./types.js";
-export * as z from "./zod.js";
+export * from "./zod.js";

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

@@ -0,0 +1,5 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/index.ts"
+force: true
+---
+export * from "./utils.js";

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

@@ -1,19 +1,31 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/types.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/types.ts"
 force: true
 ---
-import type { PHDocument, ExtendedState } from 'document-model';
-import type { <%= h.changeCase.pascal(documentType) %>State } from './schema/types.js';
+import type { PHDocument, PHBaseState } from 'document-model';
+import type { <%= actionTypeName %> } from './actions.js';
+import type {
+  <%= stateName %> as <%= globalStateName %>,
 <% if(hasLocalSchema) { -%>
-import type { <%= h.changeCase.pascal(documentType) %>LocalState } from './schema/types.js';
+  <%= localStateName %>,
 <%} -%>
-import type { <%= h.changeCase.pascal(documentType) %>Action } from './actions.js';
+} from './schema/types.js';
 
-export { z } from './schema/index.js';
-export type * from './schema/types.js';
 <% if(!hasLocalSchema) { -%>
-<%= 'type ' + h.changeCase.pascal(documentType) %>LocalState = Record<PropertyKey, never>;
+<%= 'type ' + localStateName %> = Record<PropertyKey, never>;
 <%} -%>
-export type Extended<%= h.changeCase.pascal(documentType) %>State = ExtendedState<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState>;
-export <%= 'type ' + h.changeCase.pascal(documentType) %>Document = PHDocument<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState>;
-export type { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState, <%= h.changeCase.pascal(documentType) %>Action };
+type <%= phStateName %> = PHBaseState & {
+  global: <%= globalStateName %>;
+  local: <%= localStateName %>;
+};
+type <%= phDocumentTypeName %> = PHDocument<<%= phStateName %>>;
+
+export * from './schema/types.js';
+
+export type { 
+  <%= globalStateName %>, 
+  <%= localStateName %>,
+  <%= phStateName %>, 
+  <%= actionTypeName %>,
+  <%= phDocumentTypeName %>,
+};

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

@@ -1,63 +1,77 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/utils.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/utils.ts"
 force: true
 ---
+import type {
+    DocumentModelUtils,
+} from "document-model";
 import { 
-    type DocumentModelUtils,
     baseCreateDocument,
-    baseCreateExtendedState,
-    baseSaveToFile,
     baseSaveToFileHandle,
-    baseLoadFromFile,
     baseLoadFromInput,
+    defaultBaseState,
     generateId,
- } from 'document-model';
-import { 
-  <%= 'type ' + h.changeCase.pascal(documentType) %>Document,
-  <%= 'type ' + h.changeCase.pascal(documentType) %>State,
-  <%= 'type ' + h.changeCase.pascal(documentType) %>LocalState
+ } from 'document-model/core';
+import type { 
+  <%= globalStateName %>,
+  <%= localStateName %>
 } from './types.js';
+import type { <%= phStateName %> } from './types.js';
 import { reducer } from './reducer.js';
+import { <%= documentTypeVariableName %> } from "./document-type.js";
+import {
+  <%= isPhDocumentOfTypeFunctionName %>,
+  <%= assertIsPhDocumentOfTypeFunctionName %>,
+  <%= isPhStateOfTypeFunctionName %>,
+  <%= assertIsPhStateOfTypeFunctionName %>,
+} from "./document-schema.js";
 
-export const initialGlobalState: <%= h.changeCase.pascal(documentType) %>State = <%- initialGlobalState %>;
-export const initialLocalState: <%= h.changeCase.pascal(documentType) %>LocalState = <%- initialLocalState %>;
+export const initialGlobalState: <%= globalStateName %> = <%- initialGlobalState %>;
+export const initialLocalState: <%= localStateName %> = <%- initialLocalState %>;
 
-const utils: DocumentModelUtils<<%= h.changeCase.pascal(documentType) %>Document> = {
+export const utils: DocumentModelUtils<<%= phStateName %>> = {
     fileExtension: '<%- fileExtension %>',
     createState(state) {
-        return { global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
-    },
-    createExtendedState(extendedState) {
-        return baseCreateExtendedState(
-            { ...extendedState },
-            utils.createState
-        );
+        return { ...defaultBaseState(), global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
     },
     createDocument(state) {
         const document = baseCreateDocument(
-            utils.createExtendedState(state),
-            utils.createState
+            utils.createState,
+            state
         );
 
-        document.header.documentType = '<%- documentTypeId %>';
+        document.header.documentType = <%= documentTypeVariableName %>;
 
         // for backwards compatibility, but this is NOT a valid signed document id
         document.header.id = generateId();
 
         return document;
     },
-    saveToFile(document, path, name) {
-        return baseSaveToFile(document, path, '<%- fileExtension %>', name);
-    },
     saveToFileHandle(document, input) {
         return baseSaveToFileHandle(document, input);
     },
-    loadFromFile(path) {
-        return baseLoadFromFile(path, reducer);
-    },
     loadFromInput(input) {
         return baseLoadFromInput(input, reducer);
     },
+    isStateOfType(state) {
+        return <%= isPhStateOfTypeFunctionName %>(state);
+    },
+    assertIsStateOfType(state) {
+        return <%= assertIsPhStateOfTypeFunctionName %>(state);
+    },
+    isDocumentOfType(document) {
+        return <%= isPhDocumentOfTypeFunctionName %>(document);
+    },
+    assertIsDocumentOfType(document) {
+        return <%= assertIsPhDocumentOfTypeFunctionName %>(document);
+    },
 };
 
-export default utils;
+export const createDocument = utils.createDocument;
+export const createState = utils.createState;
+export const saveToFileHandle = utils.saveToFileHandle;
+export const loadFromInput = utils.loadFromInput;
+export const isStateOfType = utils.isStateOfType;
+export const assertIsStateOfType = utils.assertIsStateOfType;
+export const isDocumentOfType = utils.isDocumentOfType;
+export const assertIsDocumentOfType = utils.assertIsDocumentOfType;

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

@@ -2,15 +2,20 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/creators.ts"
 force: true
 ---
-import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model';
-import { z,
+import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/core';
+import {
+<% actions.filter(a => a.hasInput).forEach(action => { _%>
+    <%= h.changeCase.pascal(action.name) %>InputSchema,
+<% }); _%>
+} from '../schema/zod.js';
+import type {
 <% actions.filter(a => a.hasInput).forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Input,
+    <%= h.changeCase.pascal(action.name) %>Input,
 <% }); _%>
 } from '../types.js';
-import {
+import type {
 <% actions.forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Action,
+    <%= h.changeCase.pascal(action.name) %>Action,
 <% }); _%>
 } from './actions.js';
 
@@ -20,7 +25,7 @@ export const <%= h.changeCase.camel(action.name) %> = (input: <%= h.changeCase.p
         '<%= h.changeCase.constantCase(action.name) %>',
         {...input},
         <%if(action.hasAttachment){ %>attachments<% } else { %>undefined<% } %>,
-        z.<%= h.changeCase.pascalCase(action.name) %>InputSchema,
+        <%= h.changeCase.pascalCase(action.name) %>InputSchema,
         '<%= action.scope %>'
     );
 

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

@@ -7,42 +7,37 @@ unless_exists: true
  * - change it by adding new tests or modifying the existing ones
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { generateMock } from '@powerhousedao/codegen';
-import utils from '../../gen/utils.js';
 import {
-    z,
-<% actions.forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Input,
+  reducer,
+  utils,
+  <%= isPhDocumentOfTypeFunctionName %>,
+  <% actions.forEach(action => { _%>
+    <%= h.changeCase.camel(action.name) %>,
+    <%= h.changeCase.pascal(action.name) %>InputSchema,
 <% }); _%> 
-} from '../../gen/schema/index.js';
-import { reducer } from '../../gen/reducer.js';
-import * as creators from '../../gen/<%= module %>/creators.js';
-import type { <%= h.changeCase.pascal(documentType) %>Document } from '../../gen/types.js';
+} from "<%= documentModelDir %>";
 
 describe('<%= h.changeCase.pascal(module) %> Operations', () => {
-    let document: <%= h.changeCase.pascal(documentType) %>Document;
-
-    beforeEach(() => {
-        document = utils.createDocument();
-    });
-
 <% actions.forEach(action => { _%>
     it('should handle <%= h.changeCase.camel(action.name) %> operation', () => {
-        const input: <%= h.changeCase.pascal(action.name) %>Input = generateMock(
-            z.<%= h.changeCase.pascal(action.name) %>InputSchema(),
+        const document = utils.createDocument();
+        const input = generateMock(
+            <%= h.changeCase.pascal(action.name) %>InputSchema(),
         );
 
         const updatedDocument = reducer(
             document,
-            creators.<%= h.changeCase.camel(action.name) %>(input),
+            <%= h.changeCase.camel(action.name) %>(input),
         );
 
+        expect(<%= isPhDocumentOfTypeFunctionName %>(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.<%= action.scope %>).toHaveLength(1);
-        expect(updatedDocument.operations.<%= action.scope %>[0].type).toBe(
+        expect(updatedDocument.operations.<%= action.scope %>[0].action.type).toBe(
             '<%= h.changeCase.constant(action.name) %>',
         );
-        expect(updatedDocument.operations.<%= action.scope %>[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.<%= action.scope %>[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.<%= action.scope %>[0].index).toEqual(0);
     });
 <% }); _%> 

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

@@ -2,20 +2,17 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/error.ts"
 force: true
 ---
-<% if (actions.some(action => action.errors?.length > 0)) { _%>
+<% if (errors.length > 0) { _%>
 export type ErrorCode =
-<% actions.forEach((action, actionIndex) => { _%>
-<% action.errors.forEach((error, errorIndex) => { _%>
-    | '<%= h.changeCase.pascal(error.name) %>'<% if (actionIndex === actions.length - 1 && errorIndex === action.errors.length - 1) { %>;<% } %>
-<% }); _%>
+<% errors.forEach((error, errorIndex) => { _%>
+    | '<%= h.changeCase.pascal(error.name) %>'<% if (errorIndex === errors.length - 1) { %>;<% } %>
 <% }); _%>
 
 export interface ReducerError {
     errorCode: ErrorCode;
 }
 
-<% actions.forEach(action => { _%>
-<% action.errors.forEach(error => { _%>
+<% errors.forEach(error => { _%>
 export class <%= h.changeCase.pascal(error.name) %> extends Error implements ReducerError {
     errorCode = '<%= h.changeCase.pascal(error.name) %>' as ErrorCode;
     constructor(message = '<%= h.changeCase.pascal(error.name) %>') {
@@ -23,7 +20,6 @@ export class <%= h.changeCase.pascal(error.name) %> extends Error implements Red
     }
 }
 
-<% }); _%>
 <% }); _%>
 
 <% } _%>
@@ -32,9 +28,9 @@ export const errors = {
 <% if(action.errors?.length > 0){ -%>
     <%= h.changeCase.pascal(action.name) %>: {
     <% action.errors.forEach(error => { _%>
-    <%= h.changeCase.pascal(error.name) %>,
+        <%= h.changeCase.pascal(error.name) %>,
     <% }); _%>
-},
+    },
 <% } -%>
 <% }); _%>
 };

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

@@ -1,28 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
-exports.default = {
-    params: ({ args }) => {
-        const documentModel = JSON.parse(args.documentModel);
-        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
-        const filteredModules = latestSpec.modules.filter((m) => m.name === args.module);
-        const actions = filteredModules.length > 0
-            ? filteredModules[0].operations.map((a) => ({
-                name: a.name,
-                hasInput: a.schema !== null,
-                hasAttachment: a.schema?.includes(": Attachment"),
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                scope: a.scope || "global",
-                state: a.scope === "global" ? "" : a.scope, // the state this action affects
-                errors: a.errors,
-            }))
-            : [];
-        return {
-            rootDir: args.rootDir,
-            documentType: documentModel.name,
-            module: (0, change_case_1.paramCase)(args.module),
-            actions,
-        };
-    },
+// @ts-check
+const { paramCase, pascalCase } = require("change-case");
+
+module.exports = {
+  params: ({ args }) => {
+    const documentModel = JSON.parse(args.documentModel);
+    const latestSpec =
+      documentModel.specifications[documentModel.specifications.length - 1];
+    const filteredModules = latestSpec.modules.filter(
+      (m) => m.name === args.module,
+    );
+
+    const actions =
+      filteredModules.length > 0
+        ? filteredModules[0].operations.map((a) => ({
+            name: a.name,
+            hasInput: a.schema !== null,
+            hasAttachment: a.schema?.includes(": Attachment"),
+            scope: a.scope || "global",
+            state: a.scope === "global" ? "" : a.scope, // the state this action affects
+            errors: a.errors,
+          }))
+        : [];
+
+    const errors = actions.reduce((acc, action) => {
+      action.errors.forEach((error) => {
+        // Fallback: If error code is empty, generate it from the error name in PascalCase
+        const errorCode = error.code || pascalCase(error.name || "");
+        const normalizedError = { ...error, code: errorCode };
+
+        const existingError = acc.find((e) => e.code === errorCode);
+        if (!existingError) {
+          acc.push(normalizedError);
+        } else if (
+          JSON.stringify(existingError) !== JSON.stringify(normalizedError)
+        ) {
+          console.warn(
+            `Warning: Duplicate error code "${errorCode}" with different fields found`,
+          );
+        }
+      });
+      return acc;
+    }, []);
+
+    const documentType = documentModel.name;
+    const pascalCaseDocumentType = pascalCase(documentType);
+    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
+    const isPhDocumentOfTypeFunctionName = `is${phDocumentTypeName}`;
+    const assertIsPhDocumentOfTypeFunctionName = `assertIs${phDocumentTypeName}`;
+    const paramCaseDocumentType = paramCase(documentType);
+    const packageName = args.packageName;
+    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
+    return {
+      rootDir: args.rootDir,
+      documentType: documentModel.name,
+      module: paramCase(args.module),
+      actions,
+      errors,
+      pascalCaseDocumentType,
+      paramCaseDocumentType,
+      packageName,
+      documentModelDir,
+      phDocumentTypeName,
+      isPhDocumentOfTypeFunctionName,
+      assertIsPhDocumentOfTypeFunctionName,
+    };
+  },
 };
-//# sourceMappingURL=index.js.map