@akanjs/devkit 0.0.88 → 0.0.90

package/src/{executors.cjs → executors.mjs}

@@ -1,67 +1,31 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var executors_exports = {};
-__export(executors_exports, {
-  AppExecutor: () => AppExecutor,
-  DistAppExecutor: () => DistAppExecutor,
-  DistLibExecutor: () => DistLibExecutor,
-  DistPkgExecutor: () => DistPkgExecutor,
-  Executor: () => Executor,
-  LibExecutor: () => LibExecutor,
-  PkgExecutor: () => PkgExecutor,
-  SysExecutor: () => SysExecutor,
-  WorkspaceExecutor: () => WorkspaceExecutor
-});
-module.exports = __toCommonJS(executors_exports);
-var import_common = require("@akanjs/common");
-var import_config = require("@akanjs/config");
-var import_child_process = require("child_process");
-var import_fs = __toESM(require("fs"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_dotenv = __toESM(require("dotenv"), 1);
-var import_dependencyScanner = require("./dependencyScanner");
+import { Logger } from "@akanjs/common";
+import {
+  getAppConfig,
+  getDefaultFileScan,
+  getLibConfig
+} from "@akanjs/config";
+import { exec, fork, spawn } from "child_process";
+import dotenv from "dotenv";
+import fs from "fs";
+import fsPromise from "fs/promises";
+import path from "path";
+import { TypeScriptDependencyScanner } from "./dependencyScanner";
 class Executor {
   logger;
   cwdPath;
   constructor(name, cwdPath) {
-    this.logger = new import_common.Logger(name);
+    this.logger = new Logger(name);
     this.cwdPath = cwdPath;
-    if (!import_fs.default.existsSync(cwdPath))
-      import_fs.default.mkdirSync(cwdPath, { recursive: true });
+    if (!fs.existsSync(cwdPath))
+      fs.mkdirSync(cwdPath, { recursive: true });
   }
   exec(command, options = {}) {
-    const proc = (0, import_child_process.exec)(command, { cwd: this.cwdPath, ...options });
+    const proc = exec(command, { cwd: this.cwdPath, ...options });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -73,9 +37,9 @@ class Executor {
     });
   }
   spawn(command, args = [], options = {}) {
-    const proc = (0, import_child_process.spawn)(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
+    const proc = spawn(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -87,16 +51,16 @@ class Executor {
     });
   }
   fork(modulePath, args = [], options = {}) {
-    const proc = (0, import_child_process.fork)(modulePath, args, {
+    const proc = fork(modulePath, args, {
       cwd: this.cwdPath,
       stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -108,35 +72,35 @@ class Executor {
     });
   }
   #getPath(filePath) {
-    return import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
   }
   mkdir(dirPath) {
     const writePath = this.#getPath(dirPath);
-    if (!import_fs.default.existsSync(writePath))
-      import_fs.default.mkdirSync(writePath, { recursive: true });
+    if (!fs.existsSync(writePath))
+      fs.mkdirSync(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
   exists(filePath) {
     const readPath = this.#getPath(filePath);
-    return import_fs.default.existsSync(readPath);
+    return fs.existsSync(readPath);
   }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.#getPath(filePath);
-    const dir = import_path.default.dirname(writePath);
-    if (!import_fs.default.existsSync(dir))
-      import_fs.default.mkdirSync(dir, { recursive: true });
+    const dir = path.dirname(writePath);
+    if (!fs.existsSync(dir))
+      fs.mkdirSync(dir, { recursive: true });
     const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-    if (import_fs.default.existsSync(writePath)) {
-      const currentContent = import_fs.default.readFileSync(writePath, "utf8");
+    if (fs.existsSync(writePath)) {
+      const currentContent = fs.readFileSync(writePath, "utf8");
       if (currentContent === contentStr || !overwrite)
         this.logger.verbose(`File ${writePath} is unchanged`);
       else {
-        import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+        fs.writeFileSync(writePath, contentStr, "utf8");
         this.logger.verbose(`File ${writePath} is changed`);
       }
     } else {
-      import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+      fs.writeFileSync(writePath, contentStr, "utf8");
       this.logger.verbose(`File ${writePath} is created`);
     }
     return this;
@@ -146,22 +110,22 @@ class Executor {
     return this;
   }
   getLocalFile(filePath) {
-    const filepath = import_path.default.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
+    const filepath = path.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
     const content = this.readFile(filepath);
     return { filepath, content };
   }
   readFile(filePath) {
     const readPath = this.#getPath(filePath);
-    return import_fs.default.readFileSync(readPath, "utf8");
+    return fs.readFileSync(readPath, "utf8");
   }
   readJson(filePath) {
     const readPath = this.#getPath(filePath);
-    return JSON.parse(import_fs.default.readFileSync(readPath, "utf8"));
+    return JSON.parse(fs.readFileSync(readPath, "utf8"));
   }
   async cp(srcPath, destPath) {
     const src = this.#getPath(srcPath);
     const dest = this.#getPath(destPath);
-    await import_promises.default.cp(src, dest, { recursive: true });
+    await fsPromise.cp(src, dest, { recursive: true });
   }
   log(msg) {
     this.logger.info(msg);
@@ -194,9 +158,9 @@ class Executor {
       const result = getContent.default(scanResult ?? null, dict);
       if (result === null)
         return;
-      const filename = typeof result === "object" ? result.filename : import_path.default.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : path.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname = import_path.default.dirname(targetPath);
+      const dirname = path.dirname(targetPath);
       const convertedTargetPath = Object.entries(dict).reduce(
         (path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value),
         `${dirname}/${filename}`
@@ -204,7 +168,7 @@ class Executor {
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       this.writeFile(convertedTargetPath, content);
     } else if (targetPath.endsWith(".template")) {
-      const content = await import_promises.default.readFile(templatePath, "utf8");
+      const content = await fsPromise.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
         (path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value),
         targetPath.slice(0, -9)
@@ -225,26 +189,26 @@ class Executor {
     overwrite = true
   }) {
     const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
-    if (import_fs.default.statSync(templatePath).isFile()) {
-      const filename = import_path.default.basename(templatePath);
+    if (fs.statSync(templatePath).isFile()) {
+      const filename = path.basename(templatePath);
       await this.#applyTemplateFile(
-        { templatePath, targetPath: import_path.default.join(basePath, filename), scanResult, overwrite },
+        { templatePath, targetPath: path.join(basePath, filename), scanResult, overwrite },
         dict
       );
     } else {
-      const subdirs = await import_promises.default.readdir(templatePath);
+      const subdirs = await fsPromise.readdir(templatePath);
       await Promise.all(
         subdirs.map(async (subdir) => {
-          const subpath = import_path.default.join(templatePath, subdir);
-          if (import_fs.default.statSync(subpath).isFile())
+          const subpath = path.join(templatePath, subdir);
+          if (fs.statSync(subpath).isFile())
             await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: path.join(basePath, subdir), scanResult, overwrite },
               dict
             );
           else
             await this.applyTemplate({
-              basePath: import_path.default.join(basePath, subdir),
-              template: import_path.default.join(template, subdir),
+              basePath: path.join(basePath, subdir),
+              template: path.join(template, subdir),
               scanResult,
               dict,
               overwrite
@@ -263,11 +227,11 @@ class WorkspaceExecutor extends Executor {
     this.repoName = repoName;
   }
   static fromRoot() {
-    const repoName = import_path.default.basename(process.cwd());
+    const repoName = path.basename(process.cwd());
     return new WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
   }
   getBaseDevEnv() {
-    const envFile = import_dotenv.default.parse(this.readFile(".env"));
+    const envFile = dotenv.parse(this.readFile(".env"));
     const appName = process.env.NEXT_PUBLIC_APP_NAME ?? envFile.NEXT_PUBLIC_APP_NAME;
     const repoName = process.env.NEXT_PUBLIC_REPO_NAME ?? envFile.NEXT_PUBLIC_REPO_NAME;
     if (!repoName)
@@ -333,24 +297,44 @@ class WorkspaceExecutor extends Executor {
     this.writeJson("tsconfig.json", rootTsConfig);
     return this;
   }
+  async getDirInModule(basePath, name) {
+    const AVOID_DIRS = ["__lib", "__scalar", `_${name}`];
+    const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
+      const dirs = await fsPromise.readdir(dirname);
+      await Promise.all(
+        dirs.map(async (dir) => {
+          if (AVOID_DIRS.includes(dir))
+            return;
+          const dirPath = path.join(dirname, dir);
+          if (fs.lstatSync(dirPath).isDirectory()) {
+            results.push(`${name}/${prefix}${dir}`);
+            if (maxDepth > 0)
+              await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
+          }
+        })
+      );
+      return results;
+    };
+    return await getDirs(basePath);
+  }
   async commit(message, { init = false, add = true } = {}) {
     if (init)
-      await this.exec(`git init`);
+      await this.exec(`git init --quiet`);
     if (add)
       await this.exec(`git add .`);
-    await this.exec(`git commit -m "${message}"`);
+    await this.exec(`git commit --quiet -m "${message}"`);
   }
   async #getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await import_promises.default.readdir(dirname);
+      const dirs = await fsPromise.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
             return;
-          const dirPath = import_path.default.join(dirname, dir);
-          if (import_fs.default.lstatSync(dirPath).isDirectory()) {
-            const hasTargetFile = import_fs.default.existsSync(import_path.default.join(dirPath, targetFilename));
+          const dirPath = path.join(dirname, dir);
+          if (fs.lstatSync(dirPath).isDirectory()) {
+            const hasTargetFile = fs.existsSync(path.join(dirPath, targetFilename));
             if (hasTargetFile)
               results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -370,6 +354,14 @@ class WorkspaceExecutor extends Executor {
     ];
     return scalarConstantExampleFiles;
   }
+  async getViewFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const viewExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getViewsSourceCode()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getViewsSourceCode()))).flat()
+    ];
+    return viewExampleFiles;
+  }
 }
 class SysExecutor extends Executor {
   workspace;
@@ -382,7 +374,11 @@ class SysExecutor extends Executor {
     this.type = type;
   }
   async getConfig(command) {
-    return this.type === "app" ? await (0, import_config.getAppConfig)(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name, command }) : await (0, import_config.getLibConfig)(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "lib", name: this.name, command });
+    return this.type === "app" ? await getAppConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name, command }) : await getLibConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "lib", name: this.name, command });
+  }
+  async getModules() {
+    const path2 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
+    return await this.workspace.getDirInModule(path2, this.name);
   }
   async scan({
     tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`),
@@ -391,7 +387,7 @@ class SysExecutor extends Executor {
     if (libScanResults[this.name])
       return libScanResults[this.name];
     const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
     const pkgPathSet = new Set(
       Object.keys(tsconfig.compilerOptions.paths).filter((path2) => tsconfig.compilerOptions.paths[path2].some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
@@ -408,17 +404,17 @@ class SysExecutor extends Executor {
       const pathSplitLength = path2.split("/").length;
       return tsconfig.compilerOptions.paths[path2][0].split("/").slice(1, 1 + pathSplitLength).join("/");
     }).filter((libName) => libName !== this.name);
-    if (!import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar`))
-      import_fs.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = (0, import_config.getDefaultFileScan)();
-    const dirnames = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter(
-      (name) => import_fs.default.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
+    if (!fs.existsSync(`${this.cwdPath}/lib/__scalar`))
+      fs.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
+    const files = getDefaultFileScan();
+    const dirnames = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter(
+      (name) => fs.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
     );
     const databaseDirs = dirnames.filter((name) => !name.startsWith("_"));
     const serviceDirs = dirnames.filter((name) => name.startsWith("_") && !name.startsWith("__"));
     await Promise.all(
       databaseDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", name));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.databases.push(name);
@@ -440,7 +436,7 @@ class SysExecutor extends Executor {
     await Promise.all(
       serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", dirname));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -455,12 +451,12 @@ class SysExecutor extends Executor {
         });
       })
     );
-    const scalarDirs = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
+    const scalarDirs = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
       (name) => !name.startsWith("_")
     );
     await Promise.all(
       scalarDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib/__scalar", name));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.scalars.push(name);
@@ -535,25 +531,47 @@ class SysExecutor extends Executor {
     return scanResult;
   }
   getLocalFile(filePath) {
-    const filepath = import_path.default.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
+    const filepath = path.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
     const content = this.workspace.readFile(filepath);
     return { filepath, content };
   }
   async getDatabaseModules() {
-    const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
+    const databaseModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
     return databaseModules;
   }
   async getServiceModules() {
-    const serviceModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
+    const serviceModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
     return serviceModules;
   }
   async getScalarModules() {
-    const scalarModules = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+    const scalarModules = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
     return scalarModules;
   }
-  async getViewModules() {
-    const viewModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.View.tsx`));
-    return viewModules;
+  async getViewComponents() {
+    const viewComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.View.tsx`));
+    return viewComponents;
+  }
+  async getUnitComponents() {
+    const unitComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`));
+    return unitComponents;
+  }
+  async getTemplateComponents() {
+    const templateComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`));
+    return templateComponents;
+  }
+  async getViewsSourceCode() {
+    const viewComponents = await this.getViewComponents();
+    return viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${viewComponent}.View.tsx`));
+  }
+  async getUnitsSourceCode() {
+    const unitComponents = await this.getUnitComponents();
+    return unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${unitComponent}.Unit.tsx`));
+  }
+  async getTemplatesSourceCode() {
+    const templateComponents = await this.getTemplateComponents();
+    return templateComponents.map(
+      (templateComponent) => this.getLocalFile(`lib/${templateComponent}/${templateComponent}.Template.tsx`)
+    );
   }
   async getScalarConstantFiles() {
     const scalarModules = await this.getScalarModules();
@@ -573,8 +591,10 @@ class SysExecutor extends Executor {
   }
 }
 class AppExecutor extends SysExecutor {
+  dist;
   constructor({ workspace, name }) {
     super({ workspace, name, type: "app" });
+    this.dist = new Executor(`${name} Dist App Executor`, `${this.workspace.workspaceRoot}/dist/apps/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -582,7 +602,7 @@ class AppExecutor extends SysExecutor {
     return new AppExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await (0, import_config.getAppConfig)(this.cwdPath, {
+    return await getAppConfig(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "app",
       name: this.name,
@@ -591,36 +611,26 @@ class AppExecutor extends SysExecutor {
   }
   async syncAssets(libDeps) {
     const projectPublicLibPath = `${this.cwdPath}/public/libs`;
-    if (import_fs.default.existsSync(projectPublicLibPath))
-      await import_promises.default.rm(projectPublicLibPath, { recursive: true });
-    const targetDeps = libDeps.filter((dep) => import_fs.default.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
-    await Promise.all(targetDeps.map((dep) => import_promises.default.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })));
+    if (fs.existsSync(projectPublicLibPath))
+      await fsPromise.rm(projectPublicLibPath, { recursive: true });
+    const targetDeps = libDeps.filter((dep) => fs.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
+    await Promise.all(targetDeps.map((dep) => fsPromise.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })));
     await Promise.all(
       targetDeps.map(
-        (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+        (dep) => fsPromise.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
           recursive: true
         })
       )
     );
   }
 }
-class DistAppExecutor extends Executor {
-  name;
-  constructor({ workspace, name }) {
-    super(`${name} Dist App Executor`, `${workspace.workspaceRoot}/dist/apps/${name}`);
-    this.name = name;
-  }
-  static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
-      return new DistAppExecutor({ workspace: executor, name });
-    return new DistAppExecutor({ workspace: executor.workspace, name });
-  }
-}
 class LibExecutor extends SysExecutor {
   workspaceRoot;
   repoName;
+  dist;
   constructor({ workspace, name }) {
     super({ workspace, name, type: "lib" });
+    this.dist = new Executor(`${name} Dist Lib Executor`, `${this.workspace.workspaceRoot}/dist/libs/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -628,7 +638,7 @@ class LibExecutor extends SysExecutor {
     return new LibExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await (0, import_config.getLibConfig)(this.cwdPath, {
+    return await getLibConfig(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "lib",
       name: this.name,
@@ -636,25 +646,15 @@ class LibExecutor extends SysExecutor {
     });
   }
 }
-class DistLibExecutor extends Executor {
-  name;
-  constructor({ workspace, name }) {
-    super(`${name} Dist Lib Executor`, `${workspace.workspaceRoot}/dist/libs/${name}`);
-    this.name = name;
-  }
-  static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
-      return new DistAppExecutor({ workspace: executor, name });
-    return new DistLibExecutor({ workspace: executor.workspace, name });
-  }
-}
 class PkgExecutor extends Executor {
   workspace;
   name;
+  dist;
   constructor({ workspace = WorkspaceExecutor.fromRoot(), name }) {
     super(`${name} Pkg Executor`, `${workspace.workspaceRoot}/pkgs/${name}`);
     this.workspace = workspace;
     this.name = name;
+    this.dist = new Executor(`${name} Dist Pkg Executor`, `${this.workspace.workspaceRoot}/dist/pkgs/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -666,7 +666,7 @@ class PkgExecutor extends Executor {
     tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`)
   } = {}) {
     const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
     const pkgPathSet = new Set(
       Object.keys(tsconfig.compilerOptions.paths).filter((path2) => tsconfig.compilerOptions.paths[path2].some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
@@ -684,33 +684,11 @@ class PkgExecutor extends Executor {
     return pkgScanResult;
   }
 }
-class DistPkgExecutor extends Executor {
-  workspaceRoot;
-  repoName;
-  name;
-  constructor({ workspaceRoot, repoName, name }) {
-    super(`${name} Dist Pkg Executor`, `${workspaceRoot}/dist/pkgs/${name}`);
-    this.workspaceRoot = workspaceRoot;
-    this.repoName = repoName;
-    this.name = name;
-  }
-  static from(workspaceExecutor, name) {
-    return new DistPkgExecutor({
-      workspaceRoot: workspaceExecutor.workspaceRoot,
-      repoName: workspaceExecutor.repoName,
-      name
-    });
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   AppExecutor,
-  DistAppExecutor,
-  DistLibExecutor,
-  DistPkgExecutor,
   Executor,
   LibExecutor,
   PkgExecutor,
   SysExecutor,
   WorkspaceExecutor
-});
+};

package/src/extractDeps.js

@@ -1,3 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractDeps_exports = {};
+__export(extractDeps_exports, {
+  extractDependencies: () => extractDependencies
+});
+module.exports = __toCommonJS(extractDeps_exports);
 const NODE_NATIVE_MODULE_SET = /* @__PURE__ */ new Set([
   "assert",
   "async_hooks",
@@ -75,6 +97,7 @@ const extractDependencies = (filepaths, pacakgeJson, defaultDependencies = []) =
     })
   );
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   extractDependencies
-};
+});

package/src/{extractDeps.cjs → extractDeps.mjs}

@@ -1,25 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var extractDeps_exports = {};
-__export(extractDeps_exports, {
-  extractDependencies: () => extractDependencies
-});
-module.exports = __toCommonJS(extractDeps_exports);
 const NODE_NATIVE_MODULE_SET = /* @__PURE__ */ new Set([
   "assert",
   "async_hooks",
@@ -97,7 +75,6 @@ const extractDependencies = (filepaths, pacakgeJson, defaultDependencies = []) =
     })
   );
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   extractDependencies
-});
+};