@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/index-x53a5nya.js

@@ -0,0 +1,301 @@
+// @bun
+import {
+  FileSys
+} from "./index-61keag0s.js";
+
+// pkgs/@akanjs/devkit/dependencyScanner.ts
+import { builtinModules } from "module";
+import * as path from "path";
+import ignore from "ignore";
+import ts from "typescript";
+var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
+var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
+var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
+
+class TypeScriptDependencyScanner {
+  #fileDependencies = new Map;
+  #fileRuntimeDependencies = new Map;
+  #fileTypeDependencies = new Map;
+  #visitedFiles = new Set;
+  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  directory;
+  rootPackageJson;
+  ig;
+  workspaceRoot;
+  constructor(directory, {
+    workspaceRoot,
+    rootPackageJson,
+    gitignorePatterns = []
+  }) {
+    this.directory = directory;
+    this.rootPackageJson = rootPackageJson;
+    this.ig = ignore().add(gitignorePatterns);
+    this.workspaceRoot = workspaceRoot;
+  }
+  async getMonorepoDependencies(projectName, { pkgs = [], libs = [] } = {}) {
+    const npmSet = new Set(Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies }));
+    const pkgPathSet = new Set(pkgs);
+    const libPathSet = new Set(libs.map((lib) => `@libs/${lib}`));
+    await this.getDependencies();
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = this.#getImportSetsFromDependencies([npmSet, pkgPathSet, libPathSet], this.#fileRuntimeDependencies);
+    const [npmDevDepSet] = this.#getImportSetsFromDependencies([npmSet], this.#fileTypeDependencies);
+    const pkgDeps = [...pkgPathDepSet];
+    const libDeps = [...libPathDepSet].map((path2) => path2.replace("@libs/", "")).filter((libName) => libName !== projectName);
+    return {
+      pkgDeps,
+      libDeps,
+      npmDeps: [...npmDepSet],
+      npmDevDeps: [...npmDevDepSet].filter((dep) => !npmDepSet.has(dep))
+    };
+  }
+  async getPackageBuildDependencies(projectName) {
+    const runtimeDeps = new Set;
+    const devDeps = new Set;
+    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+      excludeBuildFiles: true,
+      excludeTestFiles: true
+    });
+    const cssFiles = await this.#findCssFiles(this.directory);
+    for (const filePath of sourceFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      this.#addNormalizedImports(runtimeDeps, imports, projectName);
+      this.#addNormalizedImports(devDeps, typeImports, projectName);
+    }
+    for (const filePath of cssFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
+    }
+    const buildFilePath = path.join(this.directory, "build.ts");
+    if (await FileSys.fileExists(buildFilePath)) {
+      const fileContent = await FileSys.readText(buildFilePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
+      this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
+    }
+    for (const dep of runtimeDeps)
+      devDeps.delete(dep);
+    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const missingDeps = [];
+    for (const dep of [...runtimeDeps, ...devDeps]) {
+      if (rootDeps[dep] || await this.#hasWorkspacePackage(dep))
+        continue;
+      missingDeps.push(dep);
+    }
+    return {
+      npmDeps: [...runtimeDeps].sort(),
+      npmDevDeps: [...devDeps].sort(),
+      missingDeps: missingDeps.sort()
+    };
+  }
+  async#hasWorkspacePackage(dep) {
+    const packageJsonPath = path.join(this.workspaceRoot, "pkgs", dep, "package.json");
+    if (!await Bun.file(packageJsonPath).exists())
+      return false;
+    try {
+      const packageJson = await FileSys.readJson(packageJsonPath);
+      return packageJson.name === dep && !!packageJson.version;
+    } catch {
+      return false;
+    }
+  }
+  async getImportSets(depSets) {
+    const fileDependencies = await this.getDependencies();
+    return this.#getImportSetsFromDependencies(depSets, fileDependencies);
+  }
+  #getImportSetsFromDependencies(depSets, fileDependencies) {
+    const importedDepSets = new Array(depSets.length);
+    for (let i = 0;i < depSets.length; i++)
+      importedDepSets[i] = new Set;
+    fileDependencies.forEach((imps) => {
+      imps.forEach((imp) => {
+        if (imp.startsWith("."))
+          return;
+        const moduleName = imp;
+        const moduleNameParts = moduleName.split("/");
+        const subModuleLength = moduleNameParts.length;
+        for (let i = 0;i < subModuleLength; i++) {
+          const importName = moduleNameParts.slice(0, i + 1).join("/");
+          for (let j = 0;j < depSets.length; j++) {
+            if (depSets[j]?.has(importName)) {
+              importedDepSets[j]?.add(importName);
+              return;
+            }
+          }
+        }
+      });
+    });
+    return importedDepSets;
+  }
+  async getDependencies() {
+    this.#fileDependencies.clear();
+    this.#fileRuntimeDependencies.clear();
+    this.#fileTypeDependencies.clear();
+    this.#visitedFiles.clear();
+    const files = await this.#findTypeScriptFiles(this.directory);
+    for (const file of files)
+      await this.#analyzeFile(file, this.directory);
+    return this.#fileDependencies;
+  }
+  async#findTypeScriptFiles(directory, {
+    excludeBuildFiles = false,
+    excludeTestFiles = false
+  } = {}) {
+    const files = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.{ts,tsx}");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+        continue;
+      if (excludeBuildFiles && filePath === "build.ts")
+        continue;
+      if (excludeTestFiles && testFileRegex.test(filePath))
+        continue;
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath))
+        continue;
+      files.push(fullPath);
+    }
+    return files;
+  }
+  async#findCssFiles(directory) {
+    const files = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.css");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+        continue;
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath))
+        continue;
+      files.push(fullPath);
+    }
+    return files;
+  }
+  async#analyzeFile(filePath, baseDir) {
+    if (this.#visitedFiles.has(filePath))
+      return;
+    this.#visitedFiles.add(filePath);
+    try {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
+      const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
+      const relativePath = path.relative(baseDir, filePath);
+      this.#fileDependencies.set(relativePath, [...new Set([...resolvedImports, ...resolvedTypeImports])]);
+      this.#fileRuntimeDependencies.set(relativePath, resolvedImports);
+      this.#fileTypeDependencies.set(relativePath, resolvedTypeImports);
+    } catch {}
+  }
+  async#resolveImports(imports, filePath, baseDir) {
+    return await Promise.all(imports.map(async (importPath) => {
+      if (importPath.startsWith(".")) {
+        const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
+        return await this.#ensureExtension(resolvedPath);
+      }
+      return importPath;
+    }));
+  }
+  async#ensureExtension(filePath) {
+    if (await FileSys.fileExists(`${filePath}.ts`))
+      return `${filePath}.ts`;
+    else if (await FileSys.fileExists(`${filePath}.tsx`))
+      return `${filePath}.tsx`;
+    else if (await FileSys.fileExists(filePath))
+      return filePath;
+    return `${filePath}.ts`;
+  }
+  #extractImports(source, filePath) {
+    const transpiler = filePath.endsWith(".tsx") ? this.#tsxTranspiler : this.#tsTranspiler;
+    const scanSource = stripShebang(source);
+    const imports = new Set(transpiler.scanImports(scanSource).map((imp) => imp.path).filter(Boolean));
+    const typeImports = new Set;
+    const sourceFile = ts.createSourceFile(filePath, scanSource, ts.ScriptTarget.Latest, true);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement))
+        continue;
+      if (!ts.isStringLiteral(statement.moduleSpecifier))
+        continue;
+      const importPath = statement.moduleSpecifier.text;
+      const namedBindings = statement.importClause?.namedBindings;
+      const isNamedTypeOnlyImport = namedBindings && ts.isNamedImports(namedBindings) && namedBindings.elements.length > 0 && namedBindings.elements.every((element) => element.isTypeOnly);
+      if ((statement.importClause?.isTypeOnly || isNamedTypeOnlyImport) && !imports.has(importPath)) {
+        typeImports.add(importPath);
+      }
+    }
+    return { imports: [...imports], typeImports: [...typeImports] };
+  }
+  #extractCssPluginImports(source) {
+    const imports = new Set;
+    const pluginRegex = /@plugin\s+(?:url\()?["']([^"')]+)["']\)?/g;
+    for (const match of source.matchAll(pluginRegex)) {
+      const importPath = match[1];
+      if (importPath)
+        imports.add(importPath);
+    }
+    return [...imports];
+  }
+  #addNormalizedImports(deps, imports, projectName) {
+    for (const importPath of imports) {
+      const dep = this.#normalizePackageImport(importPath, projectName);
+      if (dep)
+        deps.add(dep);
+    }
+  }
+  #normalizePackageImport(importPath, projectName) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || importPath.startsWith("#") || importPath.startsWith("bun:") || builtinModuleSet.has(importPath))
+      return null;
+    const parts = importPath.split("/");
+    const packageName = importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+    if (!packageName || packageName === projectName || importPath.startsWith(`${projectName}/`))
+      return null;
+    return packageName;
+  }
+  generateDependencyGraph() {
+    let graph = `Dependency Graph:
+
+`;
+    for (const [file, imports] of this.#fileDependencies.entries()) {
+      graph += `${file}:
+`;
+      const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
+      const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
+      if (projectImports.length > 0) {
+        graph += `  Project dependencies:
+`;
+        projectImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      if (externalImports.length > 0) {
+        graph += `  External dependencies:
+`;
+        externalImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      graph += `
+`;
+    }
+    return graph;
+  }
+  static async from(exec) {
+    const [tsconfig, rootPackageJson, gitignorePatterns] = await Promise.all([
+      exec.getTsConfig(),
+      exec.workspace.getPackageJson(),
+      exec.workspace.getGitignorePatterns()
+    ]);
+    return new TypeScriptDependencyScanner(exec.cwdPath, {
+      workspaceRoot: exec.workspace.cwdPath,
+      tsconfig,
+      rootPackageJson,
+      gitignorePatterns
+    });
+  }
+}
+
+export { TypeScriptDependencyScanner };