@akanjs/devkit 0.9.41 → 0.9.43

package/esm/src/scanInfo.js

@@ -0,0 +1,451 @@
+import path from "path";
+import { TypeScriptDependencyScanner } from "./dependencyScanner";
+import { AppExecutor, LibExecutor, PkgExecutor } from "./executors";
+const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"];
+const serviceFileTypes = [
+  "dictionary",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+const databaseFileTypes = [
+  "constant",
+  "dictionary",
+  "document",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+class ScanInfo {
+  scanResult;
+  name;
+  scalar = /* @__PURE__ */ new Map();
+  service = /* @__PURE__ */ new Map();
+  database = /* @__PURE__ */ new Map();
+  file = Object.fromEntries(
+    databaseFileTypes.map((type) => [
+      type,
+      { all: /* @__PURE__ */ new Set(), databases: /* @__PURE__ */ new Set(), services: /* @__PURE__ */ new Set(), scalars: /* @__PURE__ */ new Set() }
+    ])
+  );
+  constants = /* @__PURE__ */ new Set();
+  dictionaries = /* @__PURE__ */ new Set();
+  documents = /* @__PURE__ */ new Set();
+  services = /* @__PURE__ */ new Set();
+  signals = /* @__PURE__ */ new Set();
+  stores = /* @__PURE__ */ new Set();
+  templates = /* @__PURE__ */ new Set();
+  units = /* @__PURE__ */ new Set();
+  utils = /* @__PURE__ */ new Set();
+  views = /* @__PURE__ */ new Set();
+  zones = /* @__PURE__ */ new Set();
+  static async getScanResult(exec) {
+    const akanConfig = await exec.getConfig();
+    const tsconfig = exec.getTsConfig();
+    const rootPackageJson = exec.workspace.getPackageJson();
+    const scanner = new TypeScriptDependencyScanner(exec.cwdPath, { tsconfig, rootPackageJson });
+    const { pkgDeps, libDeps, npmDeps } = await scanner.getMonorepoDependencies(exec.name);
+    const files = {
+      constant: { databases: [], scalars: [] },
+      dictionary: { databases: [], services: [], scalars: [] },
+      document: { databases: [], scalars: [] },
+      service: { databases: [], services: [] },
+      signal: { databases: [], services: [] },
+      store: { databases: [], services: [] },
+      template: { databases: [], services: [], scalars: [] },
+      unit: { databases: [], services: [], scalars: [] },
+      util: { databases: [], services: [], scalars: [] },
+      view: { databases: [], services: [], scalars: [] },
+      zone: { databases: [], services: [], scalars: [] }
+    };
+    const [{ dirs: dirnames }, scalarDirs] = await Promise.all([
+      exec.getFilesAndDirs("lib"),
+      exec.readdir("lib/__scalar")
+    ]);
+    const databaseDirs = [];
+    const serviceDirs = [];
+    dirnames.forEach((name) => {
+      if (name.startsWith("_")) {
+        if (name.startsWith("__"))
+          return;
+        else
+          serviceDirs.push(name);
+      } else
+        databaseDirs.push(name);
+    });
+    await Promise.all([
+      ...databaseDirs.map(async (name) => {
+        const filenames = await exec.readdir(path.join("lib", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts"))
+            files.constant.databases.push(name);
+          else if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.databases.push(name);
+          else if (filename.endsWith(".document.ts"))
+            files.document.databases.push(name);
+          else if (filename.endsWith(".service.ts"))
+            files.service.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.endsWith(".Template.tsx"))
+            files.template.databases.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.databases.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.databases.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.databases.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.databases.push(name);
+        });
+      }),
+      ...serviceDirs.map(async (dirname) => {
+        const name = dirname.slice(1);
+        const filenames = await exec.readdir(path.join("lib", dirname));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.services.push(name);
+          else if (filename.endsWith(".service.ts"))
+            files.service.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.endsWith(".Template.tsx"))
+            files.template.services.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.services.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.services.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.services.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.services.push(name);
+        });
+      }),
+      ...scalarDirs.map(async (name) => {
+        const filenames = await exec.readdir(path.join("lib/__scalar", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts"))
+            files.constant.scalars.push(name);
+          else if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.scalars.push(name);
+          else if (filename.endsWith(".document.ts"))
+            files.document.scalars.push(name);
+          else if (filename.endsWith(".Template.tsx"))
+            files.template.scalars.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.scalars.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.scalars.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.scalars.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.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(", ")}] }`
+      );
+    const scanResult = {
+      name: exec.name,
+      type: exec.type,
+      repoName: exec.workspace.repoName,
+      serveDomain: exec.workspace.getBaseDevEnv().serveDomain,
+      akanConfig,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: npmDeps.filter((dep) => !dep.startsWith("@akanjs"))
+    };
+    return scanResult;
+  }
+  constructor(scanResult) {
+    this.name = scanResult.name;
+    this.scanResult = scanResult;
+    Object.entries(scanResult.files).forEach(
+      ([key, value]) => {
+        const { databases, services, scalars } = value;
+        databases.forEach((modelName) => {
+          const model = this.database.get(modelName) ?? /* @__PURE__ */ new Set();
+          model.add(key);
+          this.database.set(modelName, model);
+          this.file[key].all.add(modelName);
+          this.file[key].databases.add(modelName);
+        });
+        services?.forEach((serviceName) => {
+          const service = this.service.get(serviceName) ?? /* @__PURE__ */ new Set();
+          service.add(key);
+          this.service.set(serviceName, service);
+          this.file[key].all.add(serviceName);
+          this.file[key].services.add(serviceName);
+        });
+        scalars?.forEach((scalarName) => {
+          const scalar = this.scalar.get(scalarName) ?? /* @__PURE__ */ new Set();
+          scalar.add(key);
+          this.scalar.set(scalarName, scalar);
+          this.file[key].all.add(scalarName);
+          this.file[key].scalars.add(scalarName);
+        });
+      }
+    );
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  getDatabaseModules() {
+    return [...this.database.keys()];
+  }
+  getServiceModules() {
+    return [...this.service.keys()];
+  }
+  getScalarModules() {
+    return [...this.scalar.keys()];
+  }
+}
+class AppInfo extends ScanInfo {
+  type = "app";
+  exec;
+  akanConfig;
+  static appInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingAppInfo = this.appInfos.get(exec.name);
+    if (existingAppInfo && !options.refresh)
+      return existingAppInfo;
+    const scanResult = await super.getScanResult(exec);
+    await Promise.all(
+      scanResult.libDeps.map(async (libName) => {
+        LibInfo.loadedLibs.add(libName);
+        const libExecutor = LibExecutor.from(exec, libName);
+        LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+      })
+    );
+    const appInfo = new AppInfo(exec, scanResult);
+    this.appInfos.set(exec.name, appInfo);
+    return appInfo;
+  }
+  constructor(exec, scanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(libName))
+      throw new Error(`LibInfo is invalid: ${libName}`);
+    return LibInfo.libInfos.get(libName);
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo)
+          throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      })
+    );
+  }
+}
+class LibInfo extends ScanInfo {
+  type = "lib";
+  exec;
+  akanConfig;
+  static loadedLibs = /* @__PURE__ */ new Set();
+  static libInfos = /* @__PURE__ */ new Map();
+  static #sortedLibIndices = null;
+  static getSortedLibIndices() {
+    if (this.#sortedLibIndices)
+      return this.#sortedLibIndices;
+    this.#sortedLibIndices = new Map(
+      [...this.libInfos.entries()].sort(([_, libInfoA], [__, libInfoB]) => libInfoA.akanConfig.libs.includes(libInfoB.name) ? 1 : -1).map(([libName], index) => [libName, index])
+    );
+    return this.#sortedLibIndices;
+  }
+  static async fromExecutor(exec, { refresh } = {}) {
+    const existingLibInfo = this.libInfos.get(exec.name);
+    if (existingLibInfo && !refresh)
+      return existingLibInfo;
+    const scanResult = await super.getScanResult(exec);
+    await Promise.all(
+      scanResult.libDeps.filter((libName) => !this.loadedLibs.has(libName)).map(async (libName) => {
+        this.loadedLibs.add(libName);
+        this.libInfos.set(libName, await LibInfo.fromExecutor(exec));
+      })
+    );
+    const libInfo = new LibInfo(exec, scanResult);
+    this.libInfos.set(exec.name, libInfo);
+    this.#sortedLibIndices = null;
+    return libInfo;
+  }
+  constructor(exec, scanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libs = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libs.get(libNameA);
+      const indexB = libs.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    if (!this.getScanResult().akanConfig.libs.includes(libName))
+      return void 0;
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(libName))
+      throw new Error(`LibInfo is invalid: ${libName}`);
+    return LibInfo.libInfos.get(libName);
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo)
+          throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      })
+    );
+  }
+}
+class PkgInfo {
+  exec;
+  name;
+  scanResult;
+  static async getScanResult(exec) {
+    const tsconfig = exec.getTsConfig();
+    const rootPackageJson = exec.workspace.getPackageJson();
+    const scanner = new TypeScriptDependencyScanner(exec.cwdPath, { tsconfig, rootPackageJson });
+    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;
+  }
+  static #pkgInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingPkgInfo = this.#pkgInfos.get(exec.name);
+    if (existingPkgInfo && !options.refresh)
+      return existingPkgInfo;
+    const scanResult = await this.getScanResult(exec);
+    const pkgInfo = new PkgInfo(exec, scanResult);
+    this.#pkgInfos.set(exec.name, pkgInfo);
+    return pkgInfo;
+  }
+  constructor(exec, scanResult) {
+    this.exec = exec;
+    this.name = exec.name;
+    this.scanResult = scanResult;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+}
+class WorkspaceInfo {
+  constructor(appInfos = /* @__PURE__ */ new Map(), libInfos = /* @__PURE__ */ new Map(), pkgInfos = /* @__PURE__ */ new Map()) {
+    this.appInfos = appInfos;
+    this.libInfos = libInfos;
+    this.pkgInfos = pkgInfos;
+  }
+  static #workspaceInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingWorkspaceInfo = this.#workspaceInfos.get(exec.name);
+    if (existingWorkspaceInfo && !options.refresh)
+      return existingWorkspaceInfo;
+    const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
+    const [appInfos, libInfos, pkgInfos] = await Promise.all([
+      Promise.all(
+        appNames.map(async (appName) => {
+          const app = AppExecutor.from(exec, appName);
+          return await app.scan();
+        })
+      ),
+      Promise.all(
+        libNames.map(async (libName) => {
+          const lib = LibExecutor.from(exec, libName);
+          return await lib.scan();
+        })
+      ),
+      Promise.all(
+        pkgNames.map(async (pkgName) => {
+          return await PkgExecutor.from(exec, pkgName).scan();
+        })
+      )
+    ]);
+    const workspaceInfo = new WorkspaceInfo(
+      new Map(appInfos.map((app) => [app.exec.name, app])),
+      new Map(libInfos.map((lib) => [lib.exec.name, lib])),
+      new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg]))
+    );
+    this.#workspaceInfos.set(exec.name, workspaceInfo);
+    return workspaceInfo;
+  }
+}
+export {
+  AppInfo,
+  LibInfo,
+  PkgInfo,
+  WorkspaceInfo
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "0.9.41",
+  "version": "0.9.43",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"

package/src/dependencyScanner.d.ts

@@ -1,7 +1,18 @@
+import type { PackageJson, TsConfigJson } from "./types";
 export declare class TypeScriptDependencyScanner {
     #private;
-    readonly directory: string;
-    constructor(directory: string);
+    private readonly directory;
+    private readonly tsconfig;
+    private readonly rootPackageJson;
+    constructor(directory: string, { tsconfig, rootPackageJson }: {
+        tsconfig: TsConfigJson;
+        rootPackageJson: PackageJson;
+    });
+    getMonorepoDependencies(projectName: string): Promise<{
+        pkgDeps: string[];
+        libDeps: string[];
+        npmDeps: string[];
+    }>;
     getImportSets(depSets: Set<string>[]): Promise<Set<string>[]>;
     getDependencies(): Promise<Map<string, string[]>>;
     generateDependencyGraph(): string;

package/src/executors.d.ts

@@ -1,7 +1,8 @@
 import { Logger } from "@akanjs/common";
-import { type AppConfigResult, AppScanResult, type LibConfigResult, LibScanResult, PkgScanResult, WorkspaceScanResult } from "@akanjs/config";
+import { type AppConfigResult, type LibConfigResult } from "@akanjs/config";
 import { ChildProcess, type ExecOptions, type ForkOptions, type SpawnOptions } from "child_process";
 import { Linter } from "./linter";
+import { AppInfo, LibInfo, PkgInfo, WorkspaceInfo } from "./scanInfo";
 import { Spinner } from "./spinner";
 import { TypeChecker } from "./typeChecker";
 import type { FileContent, PackageJson, TsConfigJson } from "./types";
@@ -33,6 +34,10 @@ export declare class Executor {
     getPath(filePath: string): string;
     mkdir(dirPath: string): this;
     readdir(dirPath: string): Promise<string[]>;
+    getFilesAndDirs(dirPath: string): Promise<{
+        files: string[];
+        dirs: string[];
+    }>;
     exists(filePath: string): boolean;
     remove(filePath: string): this;
     removeDir(dirPath: string): this;
@@ -54,11 +59,18 @@ export declare class Executor {
         indent?: number | undefined;
         enableSpin?: boolean | undefined;
     }): Spinner;
-    getTsConfig(pathname?: string): TsConfigJson;
-    _applyTemplate({ basePath, template, scanResult, dict, overwrite, }: {
+    getTsConfig(pathname?: string, { refresh }?: {
+        refresh?: boolean;
+    }): TsConfigJson;
+    setTsConfig(tsconfig: TsConfigJson): void;
+    getPackageJson({ refresh }?: {
+        refresh?: boolean;
+    }): PackageJson;
+    setPackageJson(packageJson: PackageJson): void;
+    _applyTemplate({ basePath, template, scanInfo, dict, overwrite, }: {
         basePath: string;
         template: string;
-        scanResult?: AppScanResult | LibScanResult | null;
+        scanInfo?: AppInfo | LibInfo | null;
         dict?: {
             [key: string]: string;
         };
@@ -100,15 +112,18 @@ export declare class WorkspaceExecutor extends Executor {
     repoName: string;
     emoji: string;
     constructor({ workspaceRoot, repoName }: ExecutorOptions);
-    static fromRoot(): WorkspaceExecutor;
+    static fromRoot({ workspaceRoot, repoName, }?: {
+        workspaceRoot?: string;
+        repoName?: string;
+    }): WorkspaceExecutor;
     getBaseDevEnv(): {
         repoName: string;
         serveDomain: string;
-        env: "testing" | "local" | "debug" | "develop" | "main";
+        env: "debug" | "testing" | "local" | "develop" | "main";
         portOffset: number;
         name?: string | undefined;
     };
-    scan(): Promise<WorkspaceScanResult>;
+    scan(): Promise<WorkspaceInfo>;
     getApps(): Promise<string[]>;
     getLibs(): Promise<string[]>;
     getSyss(): Promise<[string[], string[]]>;
@@ -144,19 +159,21 @@ interface SysExecutorOptions {
     type: "app" | "lib";
 }
 export declare class SysExecutor extends Executor {
+    #private;
     workspace: WorkspaceExecutor;
     name: string;
     type: "app" | "lib";
     emoji: string;
     constructor({ workspace, name, type }: SysExecutorOptions);
-    getConfig(command?: string): Promise<LibConfigResult>;
+    getConfig({ refresh }?: {
+        refresh?: boolean;
+    }): Promise<LibConfigResult>;
     getModules(): Promise<string[]>;
-    scan({ tsconfig, akanConfig, }: {
-        tsconfig?: TsConfigJson;
-        akanConfig: AppConfigResult | LibConfigResult;
-    }, libScanResults?: {
-        [key: string]: LibScanResult;
-    }): Promise<AppScanResult | LibScanResult>;
+    scan({ refresh, write, writeLib, }?: {
+        refresh?: boolean;
+        write?: boolean;
+        writeLib?: boolean;
+    }): Promise<AppInfo | LibInfo>;
     getLocalFile(targetPath: string): {
         filePath: string;
         content: string;
@@ -214,12 +231,15 @@ interface AppExecutorOptions {
     name: string;
 }
 export declare class AppExecutor extends SysExecutor {
+    #private;
     dist: Executor;
     emoji: string;
     constructor({ workspace, name }: AppExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): AppExecutor;
-    getEnv(): "testing" | "local" | "debug" | "develop" | "main";
-    getConfig(command?: string): Promise<AppConfigResult>;
+    getEnv(): "debug" | "testing" | "local" | "develop" | "main";
+    getConfig({ refresh }?: {
+        refresh?: boolean;
+    }): Promise<AppConfigResult>;
     syncAssets(libDeps: string[]): Promise<void>;
 }
 interface LibExecutorOptions {
@@ -227,29 +247,32 @@ interface LibExecutorOptions {
     name: string;
 }
 export declare class LibExecutor extends SysExecutor {
+    #private;
     workspaceRoot: string;
     repoName: string;
     dist: Executor;
     emoji: string;
     constructor({ workspace, name }: LibExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): LibExecutor;
-    getConfig(command?: string): Promise<LibConfigResult>;
+    getConfig({ refresh }?: {
+        refresh?: boolean;
+    }): Promise<LibConfigResult>;
 }
 interface PkgExecutorOptions {
     workspace?: WorkspaceExecutor;
     name: string;
 }
 export declare class PkgExecutor extends Executor {
+    #private;
     workspace: WorkspaceExecutor;
     name: string;
     dist: Executor;
     emoji: string;
     constructor({ workspace, name }: PkgExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): PkgExecutor;
-    scan({ packageJson, tsconfig, }?: {
-        packageJson?: PackageJson;
-        tsconfig?: TsConfigJson;
-    }): Promise<PkgScanResult>;
+    scan({ refresh }?: {
+        refresh?: boolean;
+    }): Promise<PkgInfo>;
 }
 interface ModuleExecutorOptions {
     sys: SysExecutor;

package/src/index.d.ts

@@ -20,3 +20,4 @@ export * from "./prompter";
 export * from "./guideline";
 export * from "./getDirname";
 export * from "./useStdoutDimensions";
+export * from "./scanInfo";