feat: add editor option to part main schematic (#88)

Author: Exeloo

e2e/part-main.test.ts

@@ -171,4 +171,62 @@ describe("part-main schematic", () => {
       expect(content).toContain("await afterRun(app);");
     });
   });
+
+  describe("with custom directory", () => {
+    it("should generate main file in the specified directory", async () => {
+      const tree = await runner.runSchematic("part-main", {
+        name: "my-app",
+        part: "client",
+        language: "ts",
+        directory: "custom-dir",
+        saveFile: resolve(tmpDir, "client.save.json"),
+      });
+      expect(tree.files).toContain("/custom-dir/client/main.ts");
+      expect(tree.files).not.toContain("/my-app/client/main.ts");
+    });
+  });
+
+  describe("editor mode", () => {
+    let tree: UnitTestTree;
+
+    beforeAll(async () => {
+      tree = await runner.runSchematic("part-main", {
+        name: "my-app",
+        part: "client",
+        language: "ts",
+        editor: true,
+        saveFile: resolve(tmpDir, "client.save.json"),
+      });
+    });
+
+    it("should generate the editor main file under .nanoforge/editor", () => {
+      expect(tree.files).toContain("/my-app/.nanoforge/editor/client/main.ts");
+    });
+
+    it("should import from @nanoforge-dev/core-editor", () => {
+      const content = tree.readContent("/my-app/.nanoforge/editor/client/main.ts");
+      expect(content).toContain('from "@nanoforge-dev/core-editor"');
+    });
+
+    it("should use IEditorRunOptions type", () => {
+      const content = tree.readContent("/my-app/.nanoforge/editor/client/main.ts");
+      expect(content).toContain("IEditorRunOptions");
+      expect(content).toContain("export async function main(options: IEditorRunOptions)");
+    });
+
+    it("should use entity params from editor save", () => {
+      const content = tree.readContent("/my-app/.nanoforge/editor/client/main.ts");
+      expect(content).toContain("options.editor.save.entities[0].components[0].params[0]");
+    });
+
+    it("should import components and systems with relative path to root", () => {
+      const content = tree.readContent("/my-app/.nanoforge/editor/client/main.ts");
+      expect(content).toContain(
+        'import { ExampleComponent } from "../../../client/components/example.component"',
+      );
+      expect(content).toContain(
+        'import { exampleSystem } from "../../../client/systems/example.system"',
+      );
+    });
+  });
 });

src/index.ts

@@ -1,2 +1 @@
-export * from "./utils";
 export * from "./defaults";

src/libs/part-main/part-main.factory.ts

@@ -33,7 +33,7 @@ const transform = (schema: PartMainSchema): PartMainOptions => {
   };
 };
 
-const generate = (options: PartMainOptions, path: string): Source => {
+const generate = (options: PartMainOptions, path: string, editor: boolean = false): Source => {
   const rules = [
     template({
       ...strings,
@@ -42,14 +42,17 @@ const generate = (options: PartMainOptions, path: string): Source => {
     move(normalize(path)),
   ];
 
-  return apply(asSource(writeMain(options, path)), rules);
+  return apply(asSource(writeMain(options, path, editor)), rules);
 };
 
-const writeMain = (options: PartMainOptions, path: string) => {
+const writeMain = (options: PartMainOptions, path: string, editor: boolean) => {
   return (tree: Tree) => {
     const save = getSave(path, options.part, options.saveFile);
-    const resPath = join(options.part as Path, `main.${options.language}`);
-    const content = generateMain(options, save);
+
+    let resPath = join(options.part as Path, `main.${options.language}`);
+    if (editor) resPath = join(".nanoforge/editor" as Path, resPath);
+
+    const content = generateMain(options, save, editor);
     fs.rmSync(join(path as Path, resPath), { force: true });
     tree.create(resPath, content);
     return tree;
@@ -65,5 +68,5 @@ const getSave = (path: string, part: "client" | "server", saveFile?: string): Sa
 export const main = (schema: PartMainSchema): Rule => {
   const options = transform(schema);
 
-  return mergeWith(generate(options, schema.directory ?? options.name));
+  return mergeWith(generate(options, schema.directory ?? options.name, schema.editor));
 };

src/libs/part-main/part-main.schema.d.ts

@@ -28,4 +28,9 @@ export interface PartMainSchema {
    * Save file path with components and systems in JSON format
    */
   saveFile?: string;
+
+  /**
+   * Build main editor
+   */
+  editor?: boolean;
 }

src/libs/part-main/schema.json

@@ -36,6 +36,11 @@
     "saveFile": {
       "type": "string",
       "description": "Save file path with components and systems in JSON format"
+    },
+    "editor": {
+      "type": "boolean",
+      "description": "Build main editor",
+      "default": false
     }
   },
   "required": ["name", "part"]

src/utils/index.ts

@@ -1,3 +1,5 @@
+import { join } from "path";
+
 import { InitFunctionEnum } from "@utils/main/enums";
 
 import { MainGenerator } from "./main.generator";
@@ -9,12 +11,12 @@ export interface MainOptions {
   initFunctions: boolean;
 }
 
-export const generateMain = (options: MainOptions, save: Save) => {
+export const generateMain = (options: MainOptions, save: Save, editor: boolean = false) => {
   const isServer = options.part === "server";
   const hasTypes = options.language === "ts";
   const initFunctions = options.initFunctions;
 
-  return new MainGenerator()
+  return (!editor ? new MainGenerator() : new MainGenerator(true, join("../../..", options.part)))
     .generateBaseImports(hasTypes)
     .generateLibsImports(save.libraries)
     .generateInitFunctionsImportsIfNeeded(initFunctions)

src/utils/main/main-functions.ts

@@ -1,4 +1,5 @@
 import { InitFunctionEnum } from "@utils/main/enums";
+import { joinRelative } from "@utils/path";
 
 import { LIBS_FUNCTIONS_NAME } from "./const";
 import {
@@ -12,32 +13,52 @@ import {
 export class MainGenerator {
   private buffer = "";
   private indentation = 0;
+  private readonly editor: boolean;
+  private readonly pathToRoot: string;
+
+  constructor(editor: boolean = false, pathToRoot: string = "") {
+    this.editor = editor;
+    this.pathToRoot = pathToRoot;
+  }
 
   toString(): string {
     return this.buffer;
   }
 
   generateBaseImports(hasTypes: boolean): MainGenerator {
-    if (hasTypes) this.writeLine(`import { type IRunOptions } from "@nanoforge-dev/common";`);
-    this.writeLine(`import { NanoforgeFactory } from "@nanoforge-dev/core";`);
+    if (this.editor) {
+      if (hasTypes)
+        this.writeLine(
+          `import { type IEditorRunOptions, NanoforgeFactory } from "@nanoforge-dev/core-editor";`,
+        );
+      else this.writeLine(`import { NanoforgeFactory } from "@nanoforge-dev/core-editor";`);
+    } else {
+      if (hasTypes) this.writeLine(`import { type IRunOptions } from "@nanoforge-dev/common";`);
+      this.writeLine(`import { NanoforgeFactory } from "@nanoforge-dev/core";`);
+    }
+
     this.endSection();
     return this;
   }
 
   generateLibsImports(libs: SaveLibrary[]): MainGenerator {
-    return this.generateImports(libs);
+    return this.generateImports(libs, false);
   }
 
   generateComponentsImports(libs: SaveComponent[]): MainGenerator {
-    return this.generateImports(libs);
+    return this.generateImports(libs, true);
   }
 
   generateSystemsImports(libs: SaveSystem[]): MainGenerator {
-    return this.generateImports(libs);
+    return this.generateImports(libs, true);
   }
 
   generateMainFunction(hasTypes: boolean, cb: (generator: MainGenerator) => void): MainGenerator {
-    this.writeLine(`export async function main(options${hasTypes ? ": IRunOptions" : ""}) {`);
+    if (this.editor)
+      this.writeLine(
+        `export async function main(options${hasTypes ? ": IEditorRunOptions" : ""}) {`,
+      );
+    else this.writeLine(`export async function main(options${hasTypes ? ": IRunOptions" : ""}) {`);
     this.indentation += 1;
     cb(this);
     this.indentation -= 1;
@@ -84,7 +105,7 @@ export class MainGenerator {
   }
 
   generateEntities(entities: SaveEntity[]): MainGenerator {
-    entities.forEach((entity) => this.generateEntity(entity));
+    entities.forEach((entity, index) => this.generateEntity(entity, index));
     return this;
   }
 
@@ -101,14 +122,17 @@ export class MainGenerator {
 
   generateInitFunctionsImportsIfNeeded(needed: boolean): MainGenerator {
     if (!needed) return this;
-    return this.generateImports([
-      { name: "afterInit", path: "./init/after-init" },
-      { name: "afterRegistryInit", path: "./init/after-registry-init" },
-      { name: "afterRun", path: "./init/after-run" },
-      { name: "beforeInit", path: "./init/before-init" },
-      { name: "beforeRegistryInit", path: "./init/before-registry-init" },
-      { name: "beforeRun", path: "./init/before-run" },
-    ]);
+    return this.generateImports(
+      [
+        { name: "afterInit", path: "./init/after-init" },
+        { name: "afterRegistryInit", path: "./init/after-registry-init" },
+        { name: "afterRun", path: "./init/after-run" },
+        { name: "beforeInit", path: "./init/before-init" },
+        { name: "beforeRegistryInit", path: "./init/before-registry-init" },
+        { name: "beforeRun", path: "./init/before-run" },
+      ],
+      true,
+    );
   }
 
   private generateInitFunction(func: InitFunctionEnum): MainGenerator {
@@ -122,19 +146,29 @@ export class MainGenerator {
     return this;
   }
 
-  private generateImports(els: { name: string; path: string }[]): MainGenerator {
+  private generateImports(els: { name: string; path: string }[], relative: boolean): MainGenerator {
     els
       .sort((a, b) => a.path.localeCompare(b.path))
-      .forEach(({ name, path }) => this.writeLine(`import { ${name} } from "${path}";`));
+      .forEach(({ name, path }) =>
+        this.writeLine(
+          `import { ${name} } from "${relative ? joinRelative(this.pathToRoot, path) : path}";`,
+        ),
+      );
     this.endSection();
     return this;
   }
 
-  private generateEntity(entity: SaveEntity): void {
+  private generateEntity(entity: SaveEntity, entityIndex: number): void {
     this.writeLine(`const ${entity.id} = registry.spawnEntity();`);
-    entity.components.forEach(({ name, params }) =>
-      this.writeLine(`registry.addComponent(${entity.id}, new ${name}(${params.join(", ")}));`),
-    );
+    entity.components.forEach(({ name, params: rawParams }, componentIndex) => {
+      const params = !this.editor
+        ? rawParams
+        : rawParams.map(
+            (_param, index) =>
+              `options.editor.save.entities[${entityIndex}].components[${componentIndex}].params[${index}]`,
+          );
+      this.writeLine(`registry.addComponent(${entity.id}, new ${name}(${params.join(", ")}));`);
+    });
     this.endSection();
   }
 

src/utils/main/main.generator.ts

@@ -0,0 +1,6 @@
+import { join } from "path";
+
+export const joinRelative = (...paths: [string, ...string[]]): string => {
+  const path = join(...paths);
+  return path.startsWith("./") || path.startsWith("../") ? path : `./${path}`;
+};