@akanjs/devkit 0.0.54 → 0.0.55

package/src/executors.cjs

@@ -0,0 +1,592 @@
+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_baseDevEnv = require("./baseDevEnv");
+var import_dependencyScanner = require("./dependencyScanner");
+class 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.verbose(`File ${writePath} is changed`);
+      }
+    } else {
+      import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+      this.logger.verbose(`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 {
+  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 = 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;
+    };
+    return await getDirs(basePath);
+  }
+}
+class SysExecutor extends Executor {
+  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, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command }) : await (0, import_config.getLibConfig)(this.cwdPath, { ...(0, import_baseDevEnv.getBaseDevEnv)(), 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 {
+  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, { ...(0, import_baseDevEnv.getBaseDevEnv)(), 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 {
+  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;
+  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, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command });
+  }
+}
+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;
+  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 {
+  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
+    });
+  }
+}

package/src/extractDeps.cjs

@@ -0,0 +1,99 @@
+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",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib"
+]);
+const extractDependencies = (filepaths, pacakgeJson, defaultDependencies = []) => {
+  if (!pacakgeJson.dependencies)
+    throw new Error("No dependencies found in package.json");
+  const dependencies = new Set(defaultDependencies);
+  const existingDependencies = /* @__PURE__ */ new Set([
+    ...Object.keys(pacakgeJson.dependencies ?? {}),
+    ...Object.keys(pacakgeJson.devDependencies ?? {})
+  ]);
+  const versionObj = {
+    ...pacakgeJson.dependencies ?? {},
+    ...pacakgeJson.devDependencies ?? {}
+  };
+  const requireRegex = /require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+  for (const { text } of filepaths) {
+    let requireMatch;
+    while ((requireMatch = requireRegex.exec(text)) !== null) {
+      const moduleName = requireMatch[1];
+      const moduleNameParts = moduleName.split("/");
+      const subModuleLength = moduleNameParts.length;
+      for (let i = 0; i < subModuleLength; i++) {
+        const libName = moduleNameParts.slice(0, i + 1).join("/");
+        if (!NODE_NATIVE_MODULE_SET.has(libName) && existingDependencies.has(libName))
+          dependencies.add(libName);
+      }
+    }
+  }
+  return Object.fromEntries(
+    [...dependencies].sort().map((dep) => {
+      const version = versionObj[dep];
+      if (!version)
+        throw new Error(`No version found for ${dep}`);
+      return [dep, version];
+    })
+  );
+};