@akanjs/devkit 0.0.39 → 0.0.40

package/src/executors.js

@@ -0,0 +1,715 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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"));
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_baseDevEnv = require("./baseDevEnv");
+var import_dependencyScanner = require("./dependencyScanner");
+class Executor {
+  static {
+    __name(this, "Executor");
+  }
+  logger;
+  cwdPath;
+  constructor(name, cwdPath) {
+    this.logger = new import_common.Logger(name);
+    this.cwdPath = cwdPath;
+    if (!import_fs.default.existsSync(cwdPath)) import_fs.default.mkdirSync(cwdPath, {
+      recursive: true
+    });
+  }
+  exec(command, options = {}) {
+    const proc = (0, import_child_process.exec)(command, {
+      cwd: this.cwdPath,
+      ...options
+    });
+    proc.stdout?.on("data", (data) => {
+      import_common.Logger.raw(data.toString());
+    });
+    proc.stderr?.on("data", (data) => {
+      import_common.Logger.raw(data.toString());
+    });
+    return new Promise((resolve, reject) => {
+      proc.on("exit", (code, signal) => {
+        if (!!code || signal) reject({
+          code,
+          signal
+        });
+        else resolve({
+          code,
+          signal
+        });
+      });
+    });
+  }
+  spawn(command, args = [], options = {}) {
+    const proc = (0, import_child_process.spawn)(command, args, {
+      cwd: this.cwdPath,
+      stdio: "inherit",
+      ...options
+    });
+    proc.stderr?.on("data", (data) => {
+      import_common.Logger.raw(data.toString());
+    });
+    return new Promise((resolve, reject) => {
+      proc.on("exit", (code, signal) => {
+        if (!!code || signal) reject({
+          code,
+          signal
+        });
+        else resolve({
+          code,
+          signal
+        });
+      });
+    });
+  }
+  fork(modulePath, args = [], options = {}) {
+    const proc = (0, import_child_process.fork)(modulePath, args, {
+      cwd: this.cwdPath,
+      stdio: [
+        "ignore",
+        "inherit",
+        "inherit",
+        "ipc"
+      ],
+      ...options
+    });
+    proc.stdout?.on("data", (data) => {
+      import_common.Logger.raw(data.toString());
+    });
+    proc.stderr?.on("data", (data) => {
+      import_common.Logger.raw(data.toString());
+    });
+    return new Promise((resolve, reject) => {
+      proc.on("exit", (code, signal) => {
+        if (!!code || signal) reject({
+          code,
+          signal
+        });
+        else resolve({
+          code,
+          signal
+        });
+      });
+    });
+  }
+  mkdir(dirPath) {
+    const writePath = import_path.default.isAbsolute(dirPath) ? dirPath : `${this.cwdPath}/${dirPath}`;
+    if (!import_fs.default.existsSync(writePath)) import_fs.default.mkdirSync(writePath, {
+      recursive: true
+    });
+    this.logger.verbose(`Make directory ${writePath}`);
+    return this;
+  }
+  writeFile(filePath, content) {
+    const writePath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    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 (import_fs.default.existsSync(writePath)) {
+      const currentContent = import_fs.default.readFileSync(writePath, "utf8");
+      if (currentContent === contentStr)
+        this.logger.verbose(`File ${writePath} is unchanged`);
+      else {
+        import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+        this.logger.debug(`File ${writePath} is changed`);
+      }
+    } else {
+      import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+      this.logger.debug(`File ${writePath} is created`);
+    }
+    return this;
+  }
+  writeJson(filePath, content) {
+    this.writeFile(filePath, JSON.stringify(content, null, 2));
+    return this;
+  }
+  readFile(filePath) {
+    const readPath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return import_fs.default.readFileSync(readPath, "utf8");
+  }
+  readJson(filePath) {
+    const readPath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return JSON.parse(import_fs.default.readFileSync(readPath, "utf8"));
+  }
+  async cp(srcPath, destPath) {
+    const src = import_path.default.isAbsolute(srcPath) ? srcPath : `${this.cwdPath}/${srcPath}`;
+    const dest = import_path.default.isAbsolute(destPath) ? destPath : `${this.cwdPath}/${destPath}`;
+    await import_promises.default.cp(src, dest, {
+      recursive: true
+    });
+  }
+  log(msg) {
+    this.logger.info(msg);
+    return this;
+  }
+  verbose(msg) {
+    this.logger.verbose(msg);
+    return this;
+  }
+  getTsConfig(pathname) {
+    const tsconfig = this.readJson(pathname);
+    if (tsconfig.extends) {
+      const extendsTsconfig = this.getTsConfig(tsconfig.extends);
+      return {
+        ...extendsTsconfig,
+        ...tsconfig,
+        compilerOptions: {
+          ...extendsTsconfig.compilerOptions,
+          ...tsconfig.compilerOptions
+        }
+      };
+    }
+    return tsconfig;
+  }
+  async #applyTemplateFile({ templatePath, targetPath, scanResult }, dict = {}) {
+    if (targetPath.endsWith(".js")) {
+      const getContent = await import(templatePath);
+      const content = getContent.default(scanResult ?? null, dict);
+      const convertedTargetPath = Object.entries(dict).reduce((path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value), targetPath.replace(".js", ".ts"));
+      if (content === null) return;
+      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 convertedTargetPath = Object.entries(dict).reduce((path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value), targetPath.slice(0, -9));
+      const convertedContent = Object.entries(dict).reduce((content2, [key, value]) => content2.replace(new RegExp(`<%= ${key} %>`, "g"), value), content);
+      this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
+      this.writeFile(convertedTargetPath, convertedContent);
+    }
+  }
+  async applyTemplate({ basePath, template, scanResult, dict = {} }) {
+    const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
+    if (import_fs.default.statSync(templatePath).isFile()) {
+      const filename = import_path.default.basename(templatePath);
+      await this.#applyTemplateFile({
+        templatePath,
+        targetPath: import_path.default.join(basePath, filename),
+        scanResult
+      }, dict);
+    } else {
+      if (!import_fs.default.existsSync(basePath)) await import_promises.default.mkdir(basePath, {
+        recursive: true
+      });
+      const subdirs = await import_promises.default.readdir(templatePath);
+      await Promise.all(subdirs.map(async (subdir) => {
+        const subpath = import_path.default.join(templatePath, subdir);
+        if (import_fs.default.statSync(subpath).isFile()) await this.#applyTemplateFile({
+          templatePath: subpath,
+          targetPath: import_path.default.join(basePath, subdir),
+          scanResult
+        }, dict);
+        else await this.applyTemplate({
+          basePath: import_path.default.join(basePath, subdir),
+          template: import_path.default.join(template, subdir),
+          scanResult,
+          dict
+        });
+      }));
+    }
+  }
+}
+class WorkspaceExecutor extends Executor {
+  static {
+    __name(this, "WorkspaceExecutor");
+  }
+  workspaceRoot;
+  repoName;
+  constructor({ workspaceRoot, repoName }) {
+    super(`${repoName} Executor`, workspaceRoot);
+    this.workspaceRoot = workspaceRoot;
+    this.repoName = repoName;
+  }
+  static fromRoot() {
+    const repoName = import_path.default.basename(process.cwd());
+    return new WorkspaceExecutor({
+      workspaceRoot: process.cwd(),
+      repoName
+    });
+  }
+  async scan() {
+    const [appNames, libNames, pkgNames] = await Promise.all([
+      this.getApps(),
+      this.getLibs(),
+      this.getPkgs()
+    ]);
+    const [appScanResults, libScanResults, pkgScanResults] = await Promise.all([
+      Promise.all(appNames.map(async (appName) => {
+        const app = AppExecutor.from(this, appName);
+        const akanConfig = await app.getConfig("scan");
+        return await app.scan({
+          akanConfig
+        });
+      })),
+      Promise.all(libNames.map(async (libName) => {
+        const lib = LibExecutor.from(this, libName);
+        const akanConfig = await lib.getConfig("scan");
+        return await lib.scan({
+          akanConfig
+        });
+      })),
+      Promise.all(pkgNames.map(async (pkgName) => {
+        return await PkgExecutor.from(this, pkgName).scan();
+      }))
+    ]);
+    return {
+      appNames,
+      libNames,
+      pkgNames,
+      apps: Object.fromEntries(appScanResults.map((app) => [
+        app.name,
+        app
+      ])),
+      libs: Object.fromEntries(libScanResults.map((lib) => [
+        lib.name,
+        lib
+      ])),
+      pkgs: Object.fromEntries(pkgScanResults.map((pkg) => [
+        pkg.name,
+        pkg
+      ]))
+    };
+  }
+  async getApps() {
+    return await this.#getDirHasFile(`${this.workspaceRoot}/apps`, "akan.config.ts");
+  }
+  async getLibs() {
+    return await this.#getDirHasFile(`${this.workspaceRoot}/libs`, "akan.config.ts");
+  }
+  async getSyss() {
+    const [appNames, libNames] = await Promise.all([
+      this.getApps(),
+      this.getLibs()
+    ]);
+    return [
+      appNames,
+      libNames
+    ];
+  }
+  async getPkgs() {
+    return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
+  }
+  async #getDirHasFile(basePath, targetFilename) {
+    const AVOID_DIRS = [
+      "node_modules",
+      "dist",
+      "public",
+      "./next"
+    ];
+    const getDirs = /* @__PURE__ */ __name(async (dirname, maxDepth = 3, results = [], prefix = "") => {
+      const dirs = await import_promises.default.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));
+          if (hasTargetFile) results.push(`${prefix}${dir}`);
+          if (maxDepth > 0) await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
+        }
+      }));
+      return results;
+    }, "getDirs");
+    return await getDirs(basePath);
+  }
+}
+class SysExecutor extends Executor {
+  static {
+    __name(this, "SysExecutor");
+  }
+  workspace;
+  name;
+  type;
+  constructor({ workspace = WorkspaceExecutor.fromRoot(), name, type }) {
+    super(`${name} Sys Executor`, `${workspace.workspaceRoot}/${type}s/${name}`);
+    this.workspace = workspace;
+    this.name = name;
+    this.type = type;
+  }
+  async getConfig(command) {
+    return this.type === "app" ? await (0, import_config.getAppConfig)(this.cwdPath, {
+      ...import_baseDevEnv.baseDevEnv,
+      appName: this.name,
+      command
+    }) : await (0, import_config.getLibConfig)(this.cwdPath, {
+      ...import_baseDevEnv.baseDevEnv,
+      appName: this.name,
+      command
+    });
+  }
+  async scan({ tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`), akanConfig }, libScanResults = {}) {
+    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 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("/*", "")));
+    const libPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths).filter((path2) => tsconfig.compilerOptions.paths[path2].some((resolve) => resolve.startsWith("libs/"))).map((path2) => path2.replace("/*", "")));
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await scanner.getImportSets([
+      npmSet,
+      pkgPathSet,
+      libPathSet
+    ]);
+    const pkgDeps = [
+      ...pkgPathDepSet
+    ].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return tsconfig.compilerOptions.paths[path2][0].split("/").slice(1, 1 + pathSplitLength).join("/");
+    });
+    const libDeps = [
+      ...libPathDepSet
+    ].map((path2) => {
+      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());
+    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));
+      filenames.forEach((filename) => {
+        if (filename.endsWith(".constant.ts")) files.constants.databases.push(name);
+        else if (filename.endsWith(".dictionary.ts")) files.dictionary.databases.push(name);
+        else if (filename.endsWith(".document.ts")) files.documents.databases.push(name);
+        else if (filename.endsWith(".service.ts")) files.services.databases.push(name);
+        else if (filename.endsWith(".signal.ts")) files.signal.databases.push(name);
+        else if (filename.endsWith(".store.ts")) files.store.databases.push(name);
+        else if (filename === "index.tsx") files.components.databases.push(name);
+      });
+    }));
+    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));
+      filenames.forEach((filename) => {
+        if (filename.endsWith(".dictionary.ts")) files.dictionary.services.push(name);
+        else if (filename.endsWith(".service.ts")) files.services.services.push(name);
+        else if (filename.endsWith(".signal.ts")) files.signal.services.push(name);
+        else if (filename.endsWith(".store.ts")) files.store.services.push(name);
+        else if (filename === "index.tsx") files.components.services.push(name);
+      });
+    }));
+    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 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);
+        else if (filename.endsWith(".dictionary.ts")) files.dictionary.scalars.push(name);
+        else if (filename.endsWith(".document.ts")) files.documents.scalars.push(name);
+        else if (filename.endsWith(".service.ts")) files.services.scalars.push(name);
+        else if (filename.endsWith(".signal.ts")) files.signal.scalars.push(name);
+        else if (filename.endsWith(".store.ts")) files.store.scalars.push(name);
+        else if (filename === "index.ts") files.components.scalars.push(name);
+      });
+    }));
+    const missingLibDeps = [];
+    libDeps.forEach((libName) => {
+      if (!akanConfig.libs.includes(libName)) missingLibDeps.push(libName);
+    });
+    if (missingLibDeps.length) throw new Error(`Missing libs: ${missingLibDeps.join(", ")}, add these dependencies in akan.config.ts as { libs: [...other deps, ${missingLibDeps.join(", ")}] }`);
+    for (const libName of libDeps) {
+      if (libScanResults[libName]) continue;
+      const lib = new LibExecutor({
+        workspace: this.workspace,
+        name: libName
+      });
+      const akanConfig2 = await lib.getConfig();
+      libScanResults[libName] = await lib.scan({
+        akanConfig: akanConfig2
+      }, libScanResults);
+    }
+    const scanResult = {
+      name: this.name,
+      type: this.type,
+      akanConfig,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: [
+        ...npmDepSet
+      ],
+      libs: Object.fromEntries(libDeps.map((libName) => [
+        libName,
+        libScanResults[libName]
+      ]))
+    };
+    await this.applyTemplate({
+      basePath: "lib",
+      template: "lib",
+      scanResult
+    });
+    await this.applyTemplate({
+      basePath: ".",
+      template: "server.ts",
+      scanResult
+    });
+    await this.applyTemplate({
+      basePath: ".",
+      template: "client.ts",
+      scanResult
+    });
+    if (this.type === "lib") await this.applyTemplate({
+      basePath: ".",
+      template: "index.ts",
+      scanResult
+    });
+    this.writeJson(`akan.${this.type}.json`, scanResult);
+    return scanResult;
+  }
+  async getDatabaseModules() {
+    const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.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`));
+    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`));
+    return scalarModules;
+  }
+}
+class AppExecutor extends SysExecutor {
+  static {
+    __name(this, "AppExecutor");
+  }
+  constructor({ workspace, name }) {
+    super({
+      workspace,
+      name,
+      type: "app"
+    });
+  }
+  static from(executor, name) {
+    if (executor instanceof WorkspaceExecutor) return new AppExecutor({
+      workspace: executor,
+      name
+    });
+    return new AppExecutor({
+      workspace: executor.workspace,
+      name
+    });
+  }
+  async getConfig(command) {
+    return await (0, import_config.getAppConfig)(this.cwdPath, {
+      ...import_baseDevEnv.baseDevEnv,
+      appName: this.name,
+      command
+    });
+  }
+  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
+    })));
+    await Promise.all(targetDeps.map((dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+      recursive: true
+    })));
+  }
+}
+class DistAppExecutor extends Executor {
+  static {
+    __name(this, "DistAppExecutor");
+  }
+  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 {
+  static {
+    __name(this, "LibExecutor");
+  }
+  workspaceRoot;
+  repoName;
+  constructor({ workspace, name }) {
+    super({
+      workspace,
+      name,
+      type: "lib"
+    });
+  }
+  static from(executor, name) {
+    if (executor instanceof WorkspaceExecutor) return new LibExecutor({
+      workspace: executor,
+      name
+    });
+    return new LibExecutor({
+      workspace: executor.workspace,
+      name
+    });
+  }
+  async getConfig(command) {
+    return await (0, import_config.getLibConfig)(this.cwdPath, {
+      ...import_baseDevEnv.baseDevEnv,
+      appName: this.name,
+      command
+    });
+  }
+}
+class DistLibExecutor extends Executor {
+  static {
+    __name(this, "DistLibExecutor");
+  }
+  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 {
+  static {
+    __name(this, "PkgExecutor");
+  }
+  workspace;
+  name;
+  constructor({ workspace = WorkspaceExecutor.fromRoot(), name }) {
+    super(`${name} Pkg Executor`, `${workspace.workspaceRoot}/pkgs/${name}`);
+    this.workspace = workspace;
+    this.name = name;
+  }
+  static from(executor, name) {
+    if (executor instanceof WorkspaceExecutor) return new PkgExecutor({
+      workspace: executor,
+      name
+    });
+    return new PkgExecutor({
+      workspace: executor.workspace,
+      name
+    });
+  }
+  async scan({ packageJson = this.readJson(`${this.cwdPath}/package.json`), 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 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("/*", "")));
+    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([
+      npmSet,
+      pkgPathSet
+    ]);
+    const pkgDeps = [
+      ...pkgPathDepSet
+    ].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return tsconfig.compilerOptions.paths[path2][0].split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((pkg) => pkg !== this.name);
+    const pkgScanResult = {
+      name: this.name,
+      pkgDeps,
+      dependencies: [
+        ...npmDepSet
+      ]
+    };
+    return pkgScanResult;
+  }
+}
+class DistPkgExecutor extends Executor {
+  static {
+    __name(this, "DistPkgExecutor");
+  }
+  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 = {
+  AppExecutor,
+  DistAppExecutor,
+  DistLibExecutor,
+  DistPkgExecutor,
+  Executor,
+  LibExecutor,
+  PkgExecutor,
+  SysExecutor,
+  WorkspaceExecutor
+});