akanjs 0.0.1 → 2.0.0-beta.1

package/cli/index.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { runCommands } from "akanjs/devkit";
+import { ApplicationCommand } from "./application/application.command";
+import { CloudCommand } from "./cloud/cloud.command";
+import { GuidelineCommand } from "./guideline/guideline.command";
+import { LibraryCommand } from "./library/library.command";
+import { ModuleCommand } from "./module/module.command";
+import { PackageCommand } from "./package/package.command";
+import { PageCommand } from "./page/page.command";
+import { ScalarCommand } from "./scalar/scalar.command";
+import { WorkspaceCommand } from "./workspace/workspace.command";
+
+void runCommands(
+  WorkspaceCommand,
+  ApplicationCommand,
+  LibraryCommand,
+  PackageCommand,
+  ModuleCommand,
+  PageCommand,
+  CloudCommand,
+  GuidelineCommand,
+  ScalarCommand,
+);

package/cli/library/library.command.ts

@@ -0,0 +1,28 @@
+import { command, Lib, Workspace } from "akanjs/devkit";
+
+import { LibraryScript } from "./library.script";
+
+export class LibraryCommand extends command("library", [LibraryScript], ({ public: target }) => ({
+  createLibrary: target({ desc: "Create a new shared library in the workspace" })
+    .arg("libName", String, { desc: "name of library" })
+    .with(Workspace)
+    .exec(async function (libName, workspace) {
+      await this.libraryScript.createLibrary(libName.toLowerCase().replace(/ /g, "-"), workspace);
+    }),
+  removeLibrary: target({ desc: "Remove a library from the workspace" })
+    .with(Lib)
+    .exec(async function (lib) {
+      await this.libraryScript.removeLibrary(lib);
+    }),
+  syncLibrary: target({ desc: "Sync dependencies and configuration for a library" })
+    .with(Lib)
+    .exec(async function (lib) {
+      await this.libraryScript.syncLibrary(lib);
+    }),
+  installLibrary: target({ desc: "Install pre-built library templates (shared, util, etc.)" })
+    .arg("libName", String, { desc: "name of library", nullable: true })
+    .with(Workspace)
+    .exec(async function (libName, workspace) {
+      await this.libraryScript.installLibrary(workspace, libName);
+    }),
+})) {}

package/cli/library/library.runner.ts

@@ -0,0 +1,69 @@
+import { type Lib, LibExecutor, runner, type Workspace } from "akanjs/devkit";
+import { compareVersions } from "compare-versions";
+
+export class LibraryRunner extends runner("library") {
+  async createLibrary(libName: string, workspace: Workspace) {
+    await workspace.exec(`mkdir -p libs/${libName}`);
+    await workspace.applyTemplate({ basePath: `libs/${libName}`, template: "libRoot", dict: { libName } });
+    await workspace.setTsPaths("lib", libName);
+    const lib = LibExecutor.from(workspace, libName);
+    return lib;
+  }
+  async removeLibrary(lib: Lib) {
+    await lib.workspace.exec(`rm -rf libs/${lib.name}`);
+    await lib.workspace.unsetTsPaths("lib", lib.name);
+  }
+
+  async #copyInstalledLibrary(workspace: Workspace, libName: string) {
+    const installedPackageJson = `node_modules/akanjs/libs/${libName}/package.json`;
+    if (!(await workspace.exists(installedPackageJson))) return false;
+    await workspace.cp(`node_modules/akanjs/libs/${libName}`, `libs/${libName}`);
+    return true;
+  }
+
+  async #copyLibraryFromRepository(workspace: Workspace, libName: string) {
+    await workspace.mkdir("node_modules/.akan");
+    if (await workspace.exists("node_modules/.akan/akanjs")) await workspace.removeDir("node_modules/.akan/akanjs");
+    await workspace.exec(`cd node_modules/.akan && git clone https://github.com/akan-team/akanjs.git`);
+    await workspace.cp(`node_modules/.akan/akanjs/libs/${libName}`, `libs/${libName}`);
+  }
+
+  async installLibrary(workspace: Workspace, libName: string) {
+    const copiedFromInstalledPackage = await this.#copyInstalledLibrary(workspace, libName);
+    if (!copiedFromInstalledPackage) await this.#copyLibraryFromRepository(workspace, libName);
+    await workspace.cp(`libs/${libName}/env/env.server.example.ts`, `libs/${libName}/env/env.server.testing.ts`);
+    await workspace.setTsPaths("lib", libName);
+    await workspace.commit(`Add ${libName} library`);
+    return LibExecutor.from(workspace, libName);
+  }
+  async mergeLibraryDependencies(lib: Lib) {
+    const libPackageJson = await lib.getPackageJson();
+    const rootPackageJson = await lib.workspace.getPackageJson();
+    const dependencies: Record<string, string> = {};
+    const devDependencies: Record<string, string> = {};
+    const libDependencies = { ...libPackageJson.dependencies, ...libPackageJson.devDependencies };
+    const rootDependencies = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const allDependencies = Object.fromEntries(
+      Object.keys({ ...libDependencies, ...rootDependencies }).map((dep) => {
+        const libVersion = libDependencies[dep] ?? "0.0.0";
+        const rootVersion = rootDependencies[dep] ?? "0.0.0";
+        const newerVersion = compareVersions(rootVersion, libVersion) > 0 ? rootVersion : libVersion;
+        return [dep, newerVersion];
+      }),
+    );
+    Object.keys(allDependencies)
+      .sort()
+      .forEach((dep) => {
+        if (!!libPackageJson.dependencies?.[dep] || !!rootPackageJson.dependencies?.[dep])
+          dependencies[dep] = allDependencies[dep];
+        else devDependencies[dep] = allDependencies[dep];
+      });
+    const newRootPackageJson = { ...rootPackageJson, dependencies, devDependencies };
+    await lib.workspace.setPackageJson(newRootPackageJson);
+    await lib.workspace.spawn("bun", ["install"]);
+    await lib.workspace.commit(`Merge ${lib.name} library dependencies`);
+  }
+
+  async testLibrary(lib: Lib) {
+  }
+}

package/cli/library/library.script.ts

@@ -0,0 +1,39 @@
+import { type Lib, script, type Workspace } from "akanjs/devkit";
+
+import { LibraryRunner } from "./library.runner";
+
+export class LibraryScript extends script("library", [LibraryRunner]) {
+  async syncLibrary(lib: Lib) {
+    const syncSpinner = lib.spinning("Syncing library...");
+    const scanInfo = await lib.scan();
+    syncSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) is synced`);
+    return scanInfo;
+  }
+
+  async createLibrary(libName: string, workspace: Workspace) {
+    const spinner = workspace.spinning(`Creating ${libName} library`);
+    const lib = await this.libraryRunner.createLibrary(libName, workspace);
+    spinner.succeed(`${libName} library (libs/${libName}) is created`);
+    await this.syncLibrary(lib);
+  }
+  async removeLibrary(lib: Lib) {
+    const spinner = lib.spinning("Removing library...");
+    await this.libraryRunner.removeLibrary(lib);
+    spinner.succeed(`Library ${lib.name} (libs/${lib.name}) is removed`);
+  }
+
+  async installLibrary(workspace: Workspace, libName: string) {
+    const installSpinner = workspace.spinning(`Installing ${libName} library`);
+    const lib = await this.libraryRunner.installLibrary(workspace, libName);
+    installSpinner.succeed(`${libName} library (libs/${libName}) is installed`);
+    const mergeSpinner = lib.spinning("Merging library dependencies...");
+    await this.libraryRunner.mergeLibraryDependencies(lib);
+    mergeSpinner.succeed(`${libName} library (libs/${libName}) dependencies merged to root package.json`);
+  }
+
+  async testLibrary(lib: Lib) {
+    const spinner = lib.spinning("Testing library...");
+    await this.libraryRunner.testLibrary(lib);
+    spinner.succeed(`Library ${lib.name} (libs/${lib.name}) test is successful`);
+  }
+}

package/cli/module/module.command.ts

@@ -0,0 +1,35 @@
+import { lowerlize } from "akanjs/common";
+import { command, Module, Sys } from "akanjs/devkit";
+
+import { ModuleScript } from "./module.script";
+
+export class ModuleCommand extends command("module", [ModuleScript], ({ public: target }) => ({
+  createModule: target({ desc: "Create a new domain module (constant, service, signal, store, UI)" })
+    .arg("moduleName", String, { desc: "name of module" })
+    .with(Sys)
+    .option("page", Boolean, { desc: "create page", default: false })
+    .exec(async function (moduleName, sys, page) {
+      const name = lowerlize(moduleName.replace(/ /g, ""));
+      await this.moduleScript.createModuleTemplate(sys, name, { page });
+    }),
+  removeModule: target({ desc: "Remove a module from an app or library" })
+    .with(Module)
+    .exec(async function (module) {
+      await this.moduleScript.removeModule(module);
+    }),
+  createView: target({ desc: "Create a View component for a module (full page view)" })
+    .with(Module)
+    .exec(async function (module) {
+      await this.moduleScript.createView(module);
+    }),
+  createUnit: target({ desc: "Create a Unit component for a module (list/card item)" })
+    .with(Module)
+    .exec(async function (module) {
+      await this.moduleScript.createUnit(module);
+    }),
+  createTemplate: target({ desc: "Create a Template component for a module (form)" })
+    .with(Module)
+    .exec(async function (module) {
+      await this.moduleScript.createTemplate(module);
+    }),
+})) {}

package/cli/module/module.prompt.ts

@@ -0,0 +1,18 @@
+import type { FileContent } from "akanjs/devkit";
+
+export interface ComponentDefaultDescriptionProps {
+  sysName: string;
+  modelName: string;
+  ModelName: string;
+  constant: string;
+  properties: { key: string; source: string }[];
+  exampleFiles: FileContent[];
+}
+
+export const componentDefaultDescription = ({
+  modelName,
+  ModelName,
+  exampleFiles,
+  constant,
+  properties,
+}: ComponentDefaultDescriptionProps) => ``;

package/cli/module/module.request.ts

@@ -0,0 +1,319 @@
+import { capitalize } from "akanjs/common";
+import type { AppConfigResult, LibConfigResult } from "akanjs/devkit";
+import { type FileContent, Prompter } from "akanjs/devkit";
+
+import * as prompt from "./module.prompt";
+
+interface ModuleRequestProps {
+  sysType: "app" | "lib";
+  sysName: string;
+  config: LibConfigResult | AppConfigResult;
+  modelName: string;
+}
+export class ModuleRequest extends Prompter {
+  sysType: "app" | "lib";
+  sysName: string;
+  config: LibConfigResult | AppConfigResult;
+  modelName: string;
+  constructor(options: ModuleRequestProps) {
+    super();
+    this.sysType = options.sysType;
+    this.sysName = options.sysName;
+    this.config = options.config;
+    this.modelName = options.modelName;
+  }
+  async requestModelConstant({
+    modelDesc,
+    modelSchemaDesign,
+    boilerplate,
+    exampleFiles,
+  }: {
+    modelDesc: string;
+    modelSchemaDesign: string;
+    boilerplate: string;
+    exampleFiles: FileContent[];
+  }) {
+    return this.makeTsFileUpdatePrompt({
+      context: `
+1. <model>.constant.ts 파일에 대한 개요
+${await this.getDocumentation("modelConstant")}
+
+2. <model>.constant.ts 파일의 Enum 작성법
+${await this.getDocumentation("enumConstant")}
+
+3. <model>.constant.ts 파일의 Field 작성법
+${await this.getDocumentation("fieldDecorator")}
+
+4. 현재 프로젝트 내 다른 constant.ts 파일들에 대한 예시
+${exampleFiles
+  .map(
+    (constant) => `
+Example file: ${constant.filePath}
+\`\`\`
+${constant.content}
+\`\`\`
+`,
+  )
+  .join("\n")}
+`,
+      request: `
+위 내용들을 바탕으로 파싱하기 쉽게 아래에 보일러플레이트에 맞게 정리해서 줘
+
+Application name: ${this.sysName}
+Model name: ${this.modelName}
+Model description: ${modelDesc}
+Model schema design: ${modelSchemaDesign}
+
+Target filename: ${this.modelName}.constant.ts
+\`\`\`typescript
+${boilerplate}
+\`\`\`
+
+만약, ${this.modelName}.constant.ts 파일 외에 다른 스칼라 모델을 추가로 작성해야한다면, 다음과 같은 형식으로 추가로 작성해줘
+\`\`\`typescript
+...파일 내용
+\`\`\`
+`,
+    });
+  }
+}
+
+interface RequestProps {
+  sysName: string;
+  modelName: string;
+  ModelName?: string;
+  boilerplate: string;
+  properties?: { key: string; source: string }[];
+  exampleFiles: FileContent[];
+}
+
+interface RequestDictionaryProps extends RequestProps {
+  constant: string;
+  modelDesc: string;
+  modelSchemaDesign: string;
+}
+
+export const requestDictionary = ({
+  sysName,
+  modelName,
+  constant,
+  modelDesc,
+  modelSchemaDesign,
+  boilerplate,
+  exampleFiles,
+}: RequestDictionaryProps) => `
+
+		-${modelName}의 스키마 정의.
+		\`\`\`
+		${constant}
+		\`\`\`
+
+	 역할부여 
+	 - Akan.js 사내 프레임워크 기반 유창한 번역가.
+ 
+		엄격한 주의사항
+		 - 모든 문장은 문법적으로 올바르게 작성
+		 - 보일러플레이트내 signalDictionary 부분은 그대로 유지
+		
+		요청사항
+		- 아래 제공할 보일러플레이트에 맞춰 번역본 소스코드 제공
+
+		Application name: ${sysName}
+		Model name: ${modelName}
+		Model description: ${modelDesc}
+		Model schema design: ${modelSchemaDesign}
+
+		Target filename: ${modelName}.dictionary.ts
+		\`\`\`
+		${boilerplate}
+		\`\`\`
+`;
+
+interface RequestTemplateProps extends RequestProps {
+  constant: string;
+  properties: { key: string; source: string }[];
+}
+
+export const requestTemplate = ({
+  sysName,
+  modelName,
+  ModelName,
+  boilerplate,
+  constant,
+  properties,
+  exampleFiles,
+}: RequestTemplateProps) => `
+		${prompt.componentDefaultDescription({
+      sysName,
+      modelName,
+      ModelName: ModelName ?? capitalize(modelName),
+      exampleFiles,
+      constant,
+      properties,
+    })}
+	 역할부여 
+	 - Akan.js 사내 프레임워크 기반 Typescript 시니어 프론트엔드 개발자.
+ 
+	 코딩 규칙
+		 - 라이브러리 사용
+		 - 아이콘: react-icons 라이브러리 사용
+		 - CSS: tailwind, DaisyUI(card/hero 같은 복잡한 컴포넌트 사용 X) 사용
+		 - Ui Component: @util/ui 라이브러리 사용
+		 - 조건부 클래스: clsx 라이브러리 사용
+	 코드 스타일
+		 - 색상: 하드코딩(bg-red) 대신 테마 색상(bg-primary) 사용
+		 - 조건부 렌더링: field && <div>... 대신 field ? <div>... : null 사용
+		 - 모델 접근: 구조분해할당 대신 ${modelName}.field 형식으로 접근
+		 - 타입 안전: ${modelName}.constant.ts의 스키마 참조하여 에러 방지
+	 필드 접근 전: 스키마의 실제 필드 리스트 작성 및 검토 필수
+	 
+	 엄격한 주의사항
+		 - UI 킷은 문서에 명시된 컴포넌트만 사용
+		 - 컴포넌트 사용 전 문서 확인 및 props 정확히 검증
+		 - 명시된 룰 외 임의 추상화 금지
+		 - dayjs 라이브러리는 akanjs/base에서 래핑하여 제공하고 있음.
+
+		요청사항
+		- 아래 제공할 기본 템플릿 코드에 추가로 컴포넌트 개발
+		- ${ModelName}.Template.tsx 코드 작성
+		- 컴포넌트 이름은 모델 이름은 스키마에 기반한 기능에 초점을 두고 작성
+		- 아래 제공할 보일러플레이트에 있는 General 컴포넌트 1개를 제외한 디자인 컴포넌트 4개 개발 
+		- 추상화 해야하는 경우가 있을 경우엔 문서를 다시 참고하고 설명된 내에서 해결해야함.
+		- 보일러플레이트에 맞게 정리해서 제공
+	- 
+	
+	Application name: ${sysName}
+	Model name: ${modelName}
+	Target filename: ${ModelName}.Template.tsx
+		\`\`\`
+		${boilerplate}
+		\`\`\`
+
+	`;
+interface RequestViewProps extends RequestProps {
+  constant: string;
+  properties: { key: string; source: string }[];
+}
+
+export const requestView = ({
+  sysName,
+  modelName,
+  ModelName,
+  boilerplate,
+  constant,
+  properties,
+  exampleFiles,
+}: RequestViewProps) => `
+	 ${prompt.componentDefaultDescription({
+     sysName,
+     modelName,
+     ModelName: ModelName ?? capitalize(modelName),
+     exampleFiles,
+     constant,
+     properties,
+   })}
+
+	 역할부여 
+	 - Akan.js 사내 프레임워크 기반 Typescript 시니어 프론트엔드 개발자.
+ 
+	 코딩 규칙
+		 - 라이브러리 사용
+		 - 아이콘: react-icons 라이브러리 사용
+		 - CSS: tailwind, DaisyUI(card/hero 같은 복잡한 컴포넌트 사용 X) 사용
+		 - Ui Component: @util/ui 라이브러리 사용
+		 - 조건부 클래스: clsx 라이브러리 사용
+	 코드 스타일
+		 - 색상: 하드코딩(bg-red) 대신 테마 색상(bg-primary) 사용
+		 - 조건부 렌더링: field && <div>... 대신 field ? <div>... : null 사용
+		 - 모델 접근: 구조분해할당 대신 ${modelName}.field 형식으로 접근
+		 - 타입 안전: ${modelName}.constant.ts의 스키마 참조하여 에러 방지
+	 필드 접근 전: 스키마의 실제 필드 리스트 작성 및 검토 필수
+	 
+	 엄격한 주의사항
+		 - UI 킷은 문서에 명시된 컴포넌트만 사용
+		 - 컴포넌트 사용 전 문서 확인 및 props 정확히 검증
+		 - 명시된 룰 외 임의 추상화 금지
+		 - dayjs 라이브러리는 akanjs/base에서 래핑하여 제공하고 있음.
+		 - util/ui 이외에 명시되있지 않은 컴포넌트 절대 사용 금지. 
+
+		요청사항
+		- 아래 제공할 기본 템플릿 코드에 추가로 컴포넌트 개발
+		- ${ModelName}.View.tsx 코드 작성
+		- 컴포넌트 이름에 ${ModelName}은 생략하며, 디자인 중점의 이름으로 작성
+		- 아래 제공할 보일러플레이트에 있는 General 컴포넌트 1개를 제외한 디자인 컴포넌트 4개 개발 
+		- 추상화 해야하는 경우가 있을 경우엔 문서를 다시 참고하고 설명된 내에서 해결해야함.
+		- 보일러플레이트에 맞게 정리해서 제공
+   		- UI 킷은 문서에 명시된 컴포넌트만 사용
+
+	Application name: ${sysName}
+	Model name: ${modelName}
+	
+	Target filename: ${ModelName}.View.tsx
+		\`\`\`
+		${boilerplate}
+		\`\`\`
+
+	`;
+
+interface RequestUnitProps extends RequestProps {
+  constant: string;
+  properties: { key: string; source: string }[];
+}
+
+export const requestUnit = ({
+  sysName,
+  modelName,
+  ModelName,
+  constant,
+  properties,
+  boilerplate,
+  exampleFiles,
+}: RequestUnitProps) => `
+	 ${prompt.componentDefaultDescription({
+     sysName,
+     modelName,
+     ModelName: ModelName ?? capitalize(modelName),
+     exampleFiles,
+     constant,
+     properties,
+   })}
+
+		역할부여 
+	 - Akan.js 사내 프레임워크 기반 Typescript 시니어 프론트엔드 개발자.
+ 
+	 코딩 규칙
+		 - 라이브러리 사용
+		 - 아이콘: react-icons 라이브러리 사용
+		 - CSS: tailwind, DaisyUI(card/hero 같은 복잡한 컴포넌트 사용 X) 사용
+		 - Ui Component: @util/ui 라이브러리 사용
+		 - 조건부 클래스: clsx 라이브러리 사용
+	 코드 스타일
+		 - 색상: 하드코딩(bg-red) 대신 테마 색상(bg-primary) 사용
+		 - 조건부 렌더링: field && <div>... 대신 field ? <div>... : null 사용
+		 - 모델 접근: 구조분해할당 대신 ${modelName}.field 형식으로 접근
+		 - 타입 안전: ${modelName}.constant.ts의 스키마 참조하여 에러 방지
+	 필드 접근 전: 스키마의 실제 필드 리스트 작성 및 검토 필수
+	 
+	 엄격한 주의사항
+		 - UI 킷은 문서에 명시된 컴포넌트만 사용
+		 - 컴포넌트 사용 전 문서 확인 및 props 정확히 검증
+		 - 명시된 룰 외 임의 추상화 금지
+		 - dayjs 라이브러리는 akanjs/base에서 래핑하여 제공하고 있음.
+	
+		요청사항
+		- 아래 제공할 기본 템플릿 코드에 추가로 컴포넌트 개발
+		- ${ModelName}.Unit.tsx 코드 작성
+		- 컴포넌트 이름에 ${ModelName}은 생략하며, 디자인 중점의 이름으로 작성
+		- 예시파일 컴포넌트의 기반하여 일반적으로 사용 가능한 컴포넌트 1개와 디자인적 요소가 포함된 컴포넌트 3개 개발
+		- 추상화 해야하는 경우가 있을 경우엔 문서를 다시 참고하고 설명된 내에서 해결해야함.
+		- 보일러플레이트에 맞게 정리해서 제공
+
+	Application name: ${sysName}
+	Model name: ${modelName}
+	
+	Target filename: ${ModelName}.Unit.tsx
+		\`\`\`
+		${boilerplate}
+		\`\`\`
+
+	`;

package/cli/module/module.runner.ts

@@ -0,0 +1,76 @@
+import { capitalize } from "akanjs/common";
+import { type Module, runner, type Workspace } from "akanjs/devkit";
+import pluralize from "pluralize";
+
+export class ModuleRunner extends runner("module") {
+  async createModule(
+    workspace: Workspace,
+    sysType: "app" | "lib",
+    sysName: string,
+    moduleName: string,
+    description: string,
+  ) {
+  }
+  async removeModule(module: Module) {
+    await module.sys.removeDir(`lib/${module.name}`);
+  }
+
+  async createComponentTemplate(module: Module, type: "unit" | "view" | "template" | "zone" | "util") {
+    await module.sys.applyTemplate({
+      basePath: `./lib/${module.name}`,
+      template: `module/__Model__.${capitalize(type)}.tsx`,
+      dict: { model: module.name, appName: module.sys.name },
+    });
+    return {
+      component: {
+        filename: `${module.name}.${capitalize(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize(module.name)}.${capitalize(type)}.tsx`),
+      },
+    };
+  }
+
+  async createModuleTemplate(module: Module) {
+    const names = pluralize(module.name);
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "module",
+      dict: { model: module.name, models: names, sysName: module.sys.name },
+    });
+
+    const [
+      constantContent,
+      dictionaryContent,
+      serviceContent,
+      storeContent,
+      signalContent,
+      unitContent,
+      viewContent,
+      templateContent,
+      zoneContent,
+      utilContent,
+    ] = await Promise.all([
+      module.readFile(`${module.name}.constant.ts`),
+      module.readFile(`${module.name}.dictionary.ts`),
+      module.readFile(`${module.name}.service.ts`),
+      module.readFile(`${module.name}.store.ts`),
+      module.readFile(`${module.name}.signal.ts`),
+      module.readFile(`${module.name}.Unit.tsx`),
+      module.readFile(`${module.name}.View.tsx`),
+      module.readFile(`${module.name}.Template.tsx`),
+      module.readFile(`${module.name}.Zone.tsx`),
+      module.readFile(`${module.name}.Util.tsx`),
+    ]);
+    return {
+      constant: { filename: `${module.name}.constant.ts`, content: constantContent },
+      dictionary: { filename: `${module.name}.dictionary.ts`, content: dictionaryContent },
+      service: { filename: `${module.name}.service.ts`, content: serviceContent },
+      store: { filename: `${module.name}.store.ts`, content: storeContent },
+      signal: { filename: `${module.name}.signal.ts`, content: signalContent },
+      unit: { filename: `${module.name}.Unit.tsx`, content: unitContent },
+      view: { filename: `${module.name}.View.tsx`, content: viewContent },
+      template: { filename: `${module.name}.Template.tsx`, content: templateContent },
+      zone: { filename: `${module.name}.Zone.tsx`, content: zoneContent },
+      util: { filename: `${module.name}.Util.tsx`, content: utilContent },
+    };
+  }
+}