@akanjs/devkit 0.0.97 → 0.0.99

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

@@ -1,6 +1,38 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as ts from "typescript";
+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 dependencyScanner_exports = {};
+__export(dependencyScanner_exports, {
+  TypeScriptDependencyScanner: () => TypeScriptDependencyScanner
+});
+module.exports = __toCommonJS(dependencyScanner_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var ts = __toESM(require("typescript"), 1);
 class TypeScriptDependencyScanner {
   constructor(directory) {
     this.directory = directory;
@@ -143,6 +175,7 @@ class TypeScriptDependencyScanner {
     return graph;
   }
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   TypeScriptDependencyScanner
-};
+});

package/src/dependencyScanner.js

@@ -1,38 +1,6 @@
-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 dependencyScanner_exports = {};
-__export(dependencyScanner_exports, {
-  TypeScriptDependencyScanner: () => TypeScriptDependencyScanner
-});
-module.exports = __toCommonJS(dependencyScanner_exports);
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var ts = __toESM(require("typescript"));
+import * as fs from "fs";
+import * as path from "path";
+import * as ts from "typescript";
 class TypeScriptDependencyScanner {
   constructor(directory) {
     this.directory = directory;
@@ -175,7 +143,6 @@ class TypeScriptDependencyScanner {
     return graph;
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   TypeScriptDependencyScanner
-});
+};

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

@@ -1,32 +1,65 @@
-import { Logger } from "@akanjs/common";
-import {
-  getAppConfig,
-  getDefaultFileScan,
-  getLibConfig
-} from "@akanjs/config";
-import chalk from "chalk";
-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";
+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,
+  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_chalk = __toESM(require("chalk"), 1);
+var import_child_process = require("child_process");
+var import_dotenv = __toESM(require("dotenv"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_dependencyScanner = require("./dependencyScanner");
 class Executor {
   logger;
   cwdPath;
   constructor(name, cwdPath) {
-    this.logger = new Logger(name);
+    this.logger = new import_common.Logger(name);
     this.cwdPath = cwdPath;
-    if (!fs.existsSync(cwdPath))
-      fs.mkdirSync(cwdPath, { recursive: true });
+    if (!import_fs.default.existsSync(cwdPath))
+      import_fs.default.mkdirSync(cwdPath, { recursive: true });
   }
   exec(command, options = {}) {
-    const proc = exec(command, { cwd: this.cwdPath, ...options });
+    const proc = (0, import_child_process.exec)(command, { cwd: this.cwdPath, ...options });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(data.toString());
+      import_common.Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(chalk.red(data.toString()));
+      import_common.Logger.raw(import_chalk.default.red(data.toString()));
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -38,12 +71,12 @@ class Executor {
     });
   }
   spawn(command, args = [], options = {}) {
-    const proc = spawn(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
+    const proc = (0, import_child_process.spawn)(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -55,16 +88,16 @@ class Executor {
     });
   }
   fork(modulePath, args = [], options = {}) {
-    const proc = fork(modulePath, args, {
+    const proc = (0, import_child_process.fork)(modulePath, args, {
       cwd: this.cwdPath,
       stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(data.toString());
+      import_common.Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(data.toString());
+      import_common.Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -76,35 +109,35 @@ class Executor {
     });
   }
   #getPath(filePath) {
-    return path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
   }
   mkdir(dirPath) {
     const writePath = this.#getPath(dirPath);
-    if (!fs.existsSync(writePath))
-      fs.mkdirSync(writePath, { recursive: true });
+    if (!import_fs.default.existsSync(writePath))
+      import_fs.default.mkdirSync(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
   exists(filePath) {
     const readPath = this.#getPath(filePath);
-    return fs.existsSync(readPath);
+    return import_fs.default.existsSync(readPath);
   }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.#getPath(filePath);
-    const dir = path.dirname(writePath);
-    if (!fs.existsSync(dir))
-      fs.mkdirSync(dir, { recursive: true });
+    const dir = import_path.default.dirname(writePath);
+    if (!import_fs.default.existsSync(dir))
+      import_fs.default.mkdirSync(dir, { recursive: true });
     const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-    if (fs.existsSync(writePath)) {
-      const currentContent = fs.readFileSync(writePath, "utf8");
+    if (import_fs.default.existsSync(writePath)) {
+      const currentContent = import_fs.default.readFileSync(writePath, "utf8");
       if (currentContent === contentStr || !overwrite)
         this.logger.verbose(`File ${writePath} is unchanged`);
       else {
-        fs.writeFileSync(writePath, contentStr, "utf8");
+        import_fs.default.writeFileSync(writePath, contentStr, "utf8");
         this.logger.verbose(`File ${writePath} is changed`);
       }
     } else {
-      fs.writeFileSync(writePath, contentStr, "utf8");
+      import_fs.default.writeFileSync(writePath, contentStr, "utf8");
       this.logger.verbose(`File ${writePath} is created`);
     }
     return this;
@@ -114,22 +147,22 @@ class Executor {
     return this;
   }
   getLocalFile(filePath) {
-    const filepath = path.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
+    const filepath = import_path.default.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
     const content = this.readFile(filepath);
     return { filepath, content };
   }
   readFile(filePath) {
     const readPath = this.#getPath(filePath);
-    return fs.readFileSync(readPath, "utf8");
+    return import_fs.default.readFileSync(readPath, "utf8");
   }
   readJson(filePath) {
     const readPath = this.#getPath(filePath);
-    return JSON.parse(fs.readFileSync(readPath, "utf8"));
+    return JSON.parse(import_fs.default.readFileSync(readPath, "utf8"));
   }
   async cp(srcPath, destPath) {
     const src = this.#getPath(srcPath);
     const dest = this.#getPath(destPath);
-    await fsPromise.cp(src, dest, { recursive: true });
+    await import_promises.default.cp(src, dest, { recursive: true });
   }
   log(msg) {
     this.logger.info(msg);
@@ -162,9 +195,9 @@ class Executor {
       const result = getContent.default(scanResult ?? null, dict);
       if (result === null)
         return;
-      const filename = typeof result === "object" ? result.filename : path.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : import_path.default.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname = path.dirname(targetPath);
+      const dirname = import_path.default.dirname(targetPath);
       const convertedTargetPath = Object.entries(dict).reduce(
         (path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value),
         `${dirname}/${filename}`
@@ -172,7 +205,7 @@ class Executor {
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       this.writeFile(convertedTargetPath, content);
     } else if (targetPath.endsWith(".template")) {
-      const content = await fsPromise.readFile(templatePath, "utf8");
+      const content = await import_promises.default.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
         (path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value),
         targetPath.slice(0, -9)
@@ -193,26 +226,26 @@ class Executor {
     overwrite = true
   }) {
     const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
-    if (fs.statSync(templatePath).isFile()) {
-      const filename = path.basename(templatePath);
+    if (import_fs.default.statSync(templatePath).isFile()) {
+      const filename = import_path.default.basename(templatePath);
       await this.#applyTemplateFile(
-        { templatePath, targetPath: path.join(basePath, filename), scanResult, overwrite },
+        { templatePath, targetPath: import_path.default.join(basePath, filename), scanResult, overwrite },
         dict
       );
     } else {
-      const subdirs = await fsPromise.readdir(templatePath);
+      const subdirs = await import_promises.default.readdir(templatePath);
       await Promise.all(
         subdirs.map(async (subdir) => {
-          const subpath = path.join(templatePath, subdir);
-          if (fs.statSync(subpath).isFile())
+          const subpath = import_path.default.join(templatePath, subdir);
+          if (import_fs.default.statSync(subpath).isFile())
             await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: path.join(basePath, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanResult, overwrite },
               dict
             );
           else
             await this.applyTemplate({
-              basePath: path.join(basePath, subdir),
-              template: path.join(template, subdir),
+              basePath: import_path.default.join(basePath, subdir),
+              template: import_path.default.join(template, subdir),
               scanResult,
               dict,
               overwrite
@@ -231,11 +264,11 @@ class WorkspaceExecutor extends Executor {
     this.repoName = repoName;
   }
   static fromRoot() {
-    const repoName = path.basename(process.cwd());
+    const repoName = import_path.default.basename(process.cwd());
     return new WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
   }
   getBaseDevEnv() {
-    const envFile = dotenv.parse(this.readFile(".env"));
+    const envFile = import_dotenv.default.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)
@@ -304,13 +337,13 @@ class WorkspaceExecutor extends Executor {
   async getDirInModule(basePath, name) {
     const AVOID_DIRS = ["__lib", "__scalar", `_${name}`];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await fsPromise.readdir(dirname);
+      const dirs = await import_promises.default.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()) {
+          const dirPath = import_path.default.join(dirname, dir);
+          if (import_fs.default.lstatSync(dirPath).isDirectory()) {
             results.push(`${name}/${prefix}${dir}`);
             if (maxDepth > 0)
               await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
@@ -331,14 +364,14 @@ class WorkspaceExecutor extends Executor {
   async #getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await fsPromise.readdir(dirname);
+      const dirs = await import_promises.default.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()) {
-            const hasTargetFile = fs.existsSync(path.join(dirPath, targetFilename));
+          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));
             if (hasTargetFile)
               results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -378,7 +411,7 @@ class SysExecutor extends Executor {
     this.type = type;
   }
   async getConfig(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 });
+    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 });
   }
   async getModules() {
     const path2 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
@@ -391,7 +424,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 TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new import_dependencyScanner.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 +441,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 (!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()
+    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()
     );
     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 fsPromise.readdir(path.join(this.cwdPath, "lib", name));
+        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.databases.push(name);
@@ -440,7 +473,7 @@ class SysExecutor extends Executor {
     await Promise.all(
       serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", dirname));
+        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -455,12 +488,12 @@ class SysExecutor extends Executor {
         });
       })
     );
-    const scalarDirs = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
+    const scalarDirs = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
       (name) => !name.startsWith("_")
     );
     await Promise.all(
       scalarDirs.map(async (name) => {
-        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib/__scalar", name));
+        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.scalars.push(name);
@@ -535,32 +568,32 @@ class SysExecutor extends Executor {
     return scanResult;
   }
   getLocalFile(filePath) {
-    const filepath = path.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
+    const filepath = import_path.default.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
     const content = this.workspace.readFile(filepath);
     return { filepath, content };
   }
   async getDatabaseModules() {
-    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`));
+    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`));
     return databaseModules;
   }
   async getServiceModules() {
-    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`));
+    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`));
     return serviceModules;
   }
   async getScalarModules() {
-    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`));
+    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`));
     return scalarModules;
   }
   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`));
+    const viewComponents = (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 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`));
+    const unitComponents = (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}.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`));
+    const templateComponents = (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}.Template.tsx`));
     return templateComponents;
   }
   async getViewsSourceCode() {
@@ -606,7 +639,7 @@ class AppExecutor extends SysExecutor {
     return new AppExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await getAppConfig(this.cwdPath, {
+    return await (0, import_config.getAppConfig)(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "app",
       name: this.name,
@@ -615,13 +648,13 @@ class AppExecutor extends SysExecutor {
   }
   async syncAssets(libDeps) {
     const projectPublicLibPath = `${this.cwdPath}/public/libs`;
-    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 })));
+    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 })));
     await Promise.all(
       targetDeps.map(
-        (dep) => fsPromise.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+        (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
           recursive: true
         })
       )
@@ -642,7 +675,7 @@ class LibExecutor extends SysExecutor {
     return new LibExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await getLibConfig(this.cwdPath, {
+    return await (0, import_config.getLibConfig)(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "lib",
       name: this.name,
@@ -670,7 +703,7 @@ class PkgExecutor extends Executor {
     tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`)
   } = {}) {
     const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new import_dependencyScanner.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("/*", ""))
@@ -688,11 +721,12 @@ class PkgExecutor extends Executor {
     return pkgScanResult;
   }
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AppExecutor,
   Executor,
   LibExecutor,
   PkgExecutor,
   SysExecutor,
   WorkspaceExecutor
-};
+});

package/src/executors.d.ts

@@ -52,7 +52,7 @@ export declare class WorkspaceExecutor extends Executor {
     getBaseDevEnv(): {
         repoName: string;
         serveDomain: string;
-        env: "testing" | "local" | "debug" | "develop" | "main";
+        env: "debug" | "testing" | "local" | "develop" | "main";
         name?: string | undefined;
     };
     scan(): Promise<WorkspaceScanResult>;