nolo-cli 0.1.30 → 0.1.32

package/buildPublishArtifactAssembly.ts

@@ -11,15 +11,29 @@ import {
 import { dirname, join, relative } from "node:path";
 import {
   collectTypeScriptSourceFiles,
+  extractLocalRelativeImports,
   findTypeScriptFiles,
 } from "./buildPublishImportAnalysis";
 
 type WarnFn = (message: string, error?: unknown) => void;
 
+type ReachableWorkspaceFilesByPackage = Record<string, string[]>;
+
+type WorkspaceFileTarget = {
+  packageName: string;
+  relativeFilePath: string;
+};
+
+type WorkspaceGraph = {
+  packageOrder: string[];
+  filesByPackage: ReachableWorkspaceFilesByPackage;
+};
+
 export type InlineWorkspaceDependenciesOptions = {
   sourceDir: string;
   distDir: string;
   workspaceDeps: string[];
+  reachableFilesByPackage?: ReachableWorkspaceFilesByPackage;
   extractExternalImports: (content: string) => string[];
   rewriteCrossPackageImports: (
     content: string,
@@ -39,13 +53,17 @@ export type BuildPublishArtifactAssemblyOptions = {
     workspaceDeps: string[],
     relativeFilePath: string
   ) => string;
-  collectWorkspaceDependencies: (
+  collectWorkspaceDependencies?: (
     sourceDir: string,
     filesToCopy: string[]
   ) => string[];
   inlineWorkspaceDependencies: (
     options: InlineWorkspaceDependenciesOptions
-  ) => Promise<{ inlinedDeps: string[]; externalDeps: Record<string, string> }>;
+  ) => Promise<{
+    inlinedDeps: string[];
+    inlinedFiles?: string[];
+    externalDeps: Record<string, string>;
+  }>;
   warn: WarnFn;
 };
 
@@ -55,6 +73,7 @@ export async function buildPublishArtifactAssembly(
   resolvedFilesToCopy: string[];
   workspaceDeps: string[];
   inlinedDeps: string[];
+  inlinedFiles: string[];
   externalDeps: Record<string, string>;
 }> {
   const {
@@ -63,7 +82,6 @@ export async function buildPublishArtifactAssembly(
     filesToCopy,
     extractExternalImports,
     rewriteCrossPackageImports,
-    collectWorkspaceDependencies,
     inlineWorkspaceDependencies,
     warn,
   } = options;
@@ -71,8 +89,15 @@ export async function buildPublishArtifactAssembly(
   rmSync(distDir, { recursive: true, force: true });
   mkdirSync(distDir, { recursive: true });
 
-  const resolvedFilesToCopy = resolveFilesToCopy(sourceDir, filesToCopy);
-  const workspaceDeps = collectWorkspaceDependencies(sourceDir, resolvedFilesToCopy);
+  const resolvedFilesToCopy = expandLocalFileDependencies(
+    sourceDir,
+    resolveFilesToCopy(sourceDir, filesToCopy)
+  );
+  const reachableWorkspaceGraph = collectReachableWorkspaceFiles(
+    sourceDir,
+    resolvedFilesToCopy
+  );
+  const workspaceDeps = reachableWorkspaceGraph.packageOrder;
 
   for (const file of resolvedFilesToCopy) {
     const sourcePath = join(sourceDir, file);
@@ -97,196 +122,166 @@ export async function buildPublishArtifactAssembly(
     }
   }
 
-  const { inlinedDeps, externalDeps } = await inlineWorkspaceDependencies({
+  const {
+    inlinedDeps,
+    inlinedFiles = [],
+    externalDeps,
+  } = await inlineWorkspaceDependencies({
     sourceDir,
     distDir,
     workspaceDeps,
+    reachableFilesByPackage: reachableWorkspaceGraph.filesByPackage,
     extractExternalImports,
     rewriteCrossPackageImports,
     warn,
   });
 
-  return { resolvedFilesToCopy, workspaceDeps, inlinedDeps, externalDeps };
+  return {
+    resolvedFilesToCopy,
+    workspaceDeps,
+    inlinedDeps,
+    inlinedFiles,
+    externalDeps,
+  };
 }
 
 export async function inlineWorkspaceDependencies(
   options: InlineWorkspaceDependenciesOptions
-): Promise<{ inlinedDeps: string[]; externalDeps: Record<string, string> }> {
+): Promise<{
+  inlinedDeps: string[];
+  inlinedFiles: string[];
+  externalDeps: Record<string, string>;
+}> {
   const {
     sourceDir,
     distDir,
     workspaceDeps,
+    reachableFilesByPackage,
     extractExternalImports,
     rewriteCrossPackageImports,
     warn,
   } = options;
   if (workspaceDeps.length === 0) {
-    return { inlinedDeps: [], externalDeps: {} };
+    return { inlinedDeps: [], inlinedFiles: [], externalDeps: {} };
   }
 
   const packagesDir = join(sourceDir, "..");
   const repoRoot = join(packagesDir, "..");
+  const workspaceGraph = reachableFilesByPackage
+    ? {
+        packageOrder: buildWorkspacePackageOrder(
+          workspaceDeps,
+          reachableFilesByPackage
+        ),
+        filesByPackage: reachableFilesByPackage,
+      }
+    : collectWholePackageWorkspaceFiles(sourceDir, workspaceDeps);
   const inlinedDeps: string[] = [];
-  const queuedDeps = [...workspaceDeps];
-  const externalDeps: Record<string, string> = {};
-
-  for (let depIndex = 0; depIndex < queuedDeps.length; depIndex++) {
-    const depName = queuedDeps[depIndex];
-    if (inlinedDeps.includes(depName)) {
-      continue;
-    }
+  const inlinedFiles: string[] = [];
 
+  for (const depName of workspaceGraph.packageOrder) {
     const depSourceDir = join(packagesDir, depName);
-    const depDestDir = join(distDir, depName);
-
     if (!existsSync(depSourceDir)) {
       warn(`Warning: workspace dependency not found: ${depSourceDir}`);
       continue;
     }
 
-    for (const discoveredDep of discoverWorkspaceImportsFromPackage({
-      depDir: depSourceDir,
-      extractExternalImports,
-      packagesDir,
-    })) {
-      if (!queuedDeps.includes(discoveredDep) && !inlinedDeps.includes(discoveredDep)) {
-        queuedDeps.push(discoveredDep);
+    for (const relativeFilePath of workspaceGraph.filesByPackage[depName] || []) {
+      if (!shouldInlineWorkspaceFile(relativeFilePath)) {
+        continue;
       }
-    }
 
-    const depPkgPath = join(depSourceDir, "package.json");
-    if (existsSync(depPkgPath)) {
-      try {
-        const depManifest = JSON.parse(readFileSync(depPkgPath, "utf8"));
-        if (depManifest.dependencies) {
-          for (const [name, version] of Object.entries(depManifest.dependencies)) {
-            if (typeof version === "string" && !version.startsWith("workspace:")) {
-              externalDeps[name] = version;
-            }
-          }
-        }
-      } catch (error) {
-        warn(`Warning: could not read package.json for ${depName}:`, error);
+      const sourcePath = join(depSourceDir, relativeFilePath);
+      if (!existsSync(sourcePath)) {
+        warn(`Warning: workspace file not found: ${sourcePath}`);
+        continue;
       }
-    }
-
-    copyDirectory(depSourceDir, depDestDir, (file) => {
-      return (
-        file.endsWith(".ts") &&
-        !file.includes("/node_modules/") &&
-        !file.endsWith(".test.ts") &&
-        !file.endsWith(".spec.ts") &&
-        !file.includes("package.json")
-      );
-    }, (file, content) => {
-      const relativeFilePath = join(depName, relative(depSourceDir, file)).replace(/\\/g, "/");
-      return rewriteCrossPackageImports(content, queuedDeps, relativeFilePath);
-    });
-
-    inlinedDeps.push(depName);
 
-    for (const discoveredDep of discoverWorkspaceImportsFromPackage({
-      depDir: depDestDir,
-      extractExternalImports,
-      packagesDir,
-    })) {
-      if (!queuedDeps.includes(discoveredDep) && !inlinedDeps.includes(discoveredDep)) {
-        queuedDeps.push(discoveredDep);
+      const distRelativePath = join(depName, relativeFilePath).replace(/\\/g, "/");
+      const destPath = join(distDir, distRelativePath);
+      const destDir = dirname(destPath);
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
       }
-    }
-  }
 
-  if (inlinedDeps.length > 0) {
-    const rootPkgPath = join(repoRoot, "package.json");
-    if (existsSync(rootPkgPath)) {
-      try {
-        const rootManifest = JSON.parse(readFileSync(rootPkgPath, "utf8"));
-        const discoveredDeps = await discoverExternalImportsFromInlinedFiles(
-          distDir,
-          inlinedDeps,
-          rootManifest,
-          extractExternalImports,
-          warn
+      if (relativeFilePath.endsWith(".ts")) {
+        const content = readFileSync(sourcePath, "utf8");
+        const rewritten = rewriteCrossPackageImports(
+          content,
+          workspaceGraph.packageOrder,
+          distRelativePath
         );
-        for (const [name, version] of Object.entries(discoveredDeps)) {
-          if (!externalDeps[name]) {
-            externalDeps[name] = version;
-          }
-        }
-      } catch (error) {
-        warn("Warning: could not analyze imports from inlined files:", error);
+        writeFileSync(destPath, rewritten);
+      } else {
+        copyFileSync(sourcePath, destPath);
       }
-    }
-  }
 
-  return { inlinedDeps, externalDeps };
-}
+      inlinedFiles.push(distRelativePath);
+    }
 
-function discoverWorkspaceImportsFromPackage(args: {
-  depDir: string;
-  extractExternalImports: (content: string) => string[];
-  packagesDir: string;
-}): string[] {
-  const discovered = new Set<string>();
-  const { depDir, extractExternalImports, packagesDir } = args;
-  if (!existsSync(depDir)) {
-    return [];
+    inlinedDeps.push(depName);
   }
 
-  for (const filePath of findTypeScriptFiles(depDir)) {
-    const content = readFileSync(filePath, "utf8");
-    for (const importName of extractExternalImports(content)) {
-      if (existsSync(join(packagesDir, importName, "package.json"))) {
-        discovered.add(importName);
-      }
-    }
-  }
+  const externalDeps = discoverExternalImportsFromWorkspaceFiles({
+    packagesDir,
+    repoRoot,
+    extractExternalImports,
+    filesByPackage: workspaceGraph.filesByPackage,
+    workspacePackageDirs: new Set(workspaceGraph.packageOrder),
+    warn,
+  });
 
-  return Array.from(discovered);
+  return { inlinedDeps, inlinedFiles, externalDeps };
 }
 
-async function discoverExternalImportsFromInlinedFiles(
-  distDir: string,
-  inlinedDeps: string[],
-  rootManifest: Record<string, any>,
-  extractExternalImports: (content: string) => string[],
-  warn: WarnFn
-): Promise<Record<string, string>> {
-  const externalDeps: Record<string, string> = {};
-  const rootDeps: Record<string, string> = {};
+export { collectTypeScriptSourceFiles, findTypeScriptFiles };
 
-  if (rootManifest.dependencies) {
-    for (const [name, version] of Object.entries(rootManifest.dependencies)) {
-      if (typeof version === "string" && !version.startsWith("workspace:")) {
-        rootDeps[name] = version;
-      }
-    }
-  }
+export function expandLocalFileDependencies(sourceDir: string, filesToCopy: string[]): string[] {
+  const resolved = new Set(filesToCopy);
+  const pending = filesToCopy.filter((file) => file.endsWith(".ts"));
 
-  for (const depName of inlinedDeps) {
-    const depDir = join(distDir, depName);
-    if (!existsSync(depDir)) {
+  while (pending.length > 0) {
+    const relativeFilePath = pending.pop()!;
+    const absoluteFilePath = join(sourceDir, relativeFilePath);
+    if (!existsSync(absoluteFilePath)) {
       continue;
     }
 
-    for (const filePath of findTypeScriptFiles(depDir)) {
-      try {
-        const content = readFileSync(filePath, "utf8");
-        for (const importName of extractExternalImports(content)) {
-          if (rootDeps[importName]) {
-            externalDeps[importName] = rootDeps[importName];
-          }
-        }
-      } catch (error) {
-        warn(`Warning: could not scan ${filePath}:`, error);
+    const content = readFileSync(absoluteFilePath, "utf8");
+    for (const importPath of extractLocalRelativeImports(content)) {
+      const discoveredPath = resolveLocalImportPath(sourceDir, relativeFilePath, importPath);
+      if (!discoveredPath || resolved.has(discoveredPath)) {
+        continue;
+      }
+      resolved.add(discoveredPath);
+      if (discoveredPath.endsWith(".ts")) {
+        pending.push(discoveredPath);
       }
     }
   }
 
-  return externalDeps;
+  return Array.from(resolved);
 }
 
-export { collectTypeScriptSourceFiles, findTypeScriptFiles };
+function resolveLocalImportPath(
+  sourceDir: string,
+  relativeFilePath: string,
+  importPath: string
+): string | null {
+  const fileDir = dirname(join(sourceDir, relativeFilePath));
+  const importBase = join(fileDir, importPath);
+  const candidate = resolveImportAbsolutePath(importBase);
+  if (!candidate) {
+    return null;
+  }
+
+  const resolvedRelativePath = relative(sourceDir, candidate).replace(/\\/g, "/");
+  if (resolvedRelativePath.startsWith("..")) {
+    return null;
+  }
+
+  return resolvedRelativePath;
+}
 
 export function resolveFilesToCopy(sourceDir: string, filesToCopy: string[]): string[] {
   const resolved = new Set<string>();
@@ -344,3 +339,386 @@ export function copyDirectory(
     }
   }
 }
+
+function collectReachableWorkspaceFiles(
+  sourceDir: string,
+  entryFiles: string[]
+): WorkspaceGraph {
+  const packagesDir = join(sourceDir, "..");
+  const workspacePackageDirs = listWorkspacePackageDirs(sourceDir);
+  const packageOrder: string[] = [];
+  const filesByPackage = new Map<string, Set<string>>();
+  const pending: WorkspaceFileTarget[] = [];
+
+  const enqueue = (target: WorkspaceFileTarget | null) => {
+    if (!target || !shouldInlineWorkspaceFile(target.relativeFilePath)) {
+      return;
+    }
+
+    let files = filesByPackage.get(target.packageName);
+    if (!files) {
+      files = new Set<string>();
+      filesByPackage.set(target.packageName, files);
+      packageOrder.push(target.packageName);
+    }
+    if (files.has(target.relativeFilePath)) {
+      return;
+    }
+    files.add(target.relativeFilePath);
+    if (target.relativeFilePath.endsWith(".ts")) {
+      pending.push(target);
+    }
+  };
+
+  for (const relativeFilePath of entryFiles) {
+    if (!relativeFilePath.endsWith(".ts")) {
+      continue;
+    }
+    const sourcePath = join(sourceDir, relativeFilePath);
+    if (!existsSync(sourcePath)) {
+      continue;
+    }
+    const content = readFileSync(sourcePath, "utf8");
+    for (const importPath of extractModuleSpecifiers(content)) {
+      enqueue(
+        resolveWorkspaceImport({
+          packagesDir,
+          workspacePackageDirs,
+          importerPackageDir: sourceDir,
+          importerRelativeFilePath: relativeFilePath,
+          importPath,
+        })
+      );
+    }
+  }
+
+  while (pending.length > 0) {
+    const target = pending.pop()!;
+    const packageDir = join(packagesDir, target.packageName);
+    const sourcePath = join(packageDir, target.relativeFilePath);
+    if (!existsSync(sourcePath)) {
+      continue;
+    }
+
+    const content = readFileSync(sourcePath, "utf8");
+    for (const importPath of extractModuleSpecifiers(content)) {
+      enqueue(
+        resolveWorkspaceImport({
+          packagesDir,
+          workspacePackageDirs,
+          importerPackageDir: packageDir,
+          importerRelativeFilePath: target.relativeFilePath,
+          importPath,
+        })
+      );
+    }
+  }
+
+  return {
+    packageOrder,
+    filesByPackage: Object.fromEntries(
+      packageOrder.map((packageName) => [
+        packageName,
+        Array.from(filesByPackage.get(packageName) ?? []),
+      ])
+    ),
+  };
+}
+
+function collectWholePackageWorkspaceFiles(
+  sourceDir: string,
+  workspaceDeps: string[]
+): WorkspaceGraph {
+  const packagesDir = join(sourceDir, "..");
+  const workspacePackageDirs = listWorkspacePackageDirs(sourceDir);
+  const packageOrder: string[] = [];
+  const filesByPackage = new Map<string, Set<string>>();
+  const pendingPackages = [...workspaceDeps];
+
+  const addWholePackage = (packageName: string) => {
+    if (filesByPackage.has(packageName)) {
+      return;
+    }
+
+    const depDir = join(packagesDir, packageName);
+    if (!existsSync(depDir)) {
+      return;
+    }
+
+    const packageFiles = new Set(
+      findTypeScriptFiles(depDir)
+        .map((filePath) => relative(depDir, filePath).replace(/\\/g, "/"))
+        .filter((relativeFilePath) => shouldInlineWorkspaceFile(relativeFilePath))
+    );
+    filesByPackage.set(packageName, packageFiles);
+    packageOrder.push(packageName);
+
+    for (const relativeFilePath of packageFiles) {
+      const content = readFileSync(join(depDir, relativeFilePath), "utf8");
+      for (const importPath of extractModuleSpecifiers(content)) {
+        const resolved = resolveWorkspaceImport({
+          packagesDir,
+          workspacePackageDirs,
+          importerPackageDir: depDir,
+          importerRelativeFilePath: relativeFilePath,
+          importPath,
+        });
+        if (!resolved || filesByPackage.has(resolved.packageName)) {
+          continue;
+        }
+        pendingPackages.push(resolved.packageName);
+      }
+    }
+  };
+
+  while (pendingPackages.length > 0) {
+    addWholePackage(pendingPackages.shift()!);
+  }
+
+  return {
+    packageOrder,
+    filesByPackage: Object.fromEntries(
+      packageOrder.map((packageName) => [
+        packageName,
+        Array.from(filesByPackage.get(packageName) ?? []),
+      ])
+    ),
+  };
+}
+
+function buildWorkspacePackageOrder(
+  workspaceDeps: string[],
+  filesByPackage: ReachableWorkspaceFilesByPackage
+): string[] {
+  const ordered = new Set(workspaceDeps);
+  for (const packageName of Object.keys(filesByPackage)) {
+    ordered.add(packageName);
+  }
+  return Array.from(ordered);
+}
+
+function discoverExternalImportsFromWorkspaceFiles(args: {
+  packagesDir: string;
+  repoRoot: string;
+  extractExternalImports: (content: string) => string[];
+  filesByPackage: ReachableWorkspaceFilesByPackage;
+  workspacePackageDirs: Set<string>;
+  warn: WarnFn;
+}): Record<string, string> {
+  const {
+    packagesDir,
+    repoRoot,
+    extractExternalImports,
+    filesByPackage,
+    workspacePackageDirs,
+    warn,
+  } = args;
+  const externalDeps: Record<string, string> = {};
+  const rootDeps = readManifestDependencies(join(repoRoot, "package.json"), warn);
+
+  for (const [packageName, files] of Object.entries(filesByPackage)) {
+    const packageDeps = readManifestDependencies(
+      join(packagesDir, packageName, "package.json"),
+      warn
+    );
+    for (const relativeFilePath of files) {
+      if (!relativeFilePath.endsWith(".ts")) {
+        continue;
+      }
+
+      const sourcePath = join(packagesDir, packageName, relativeFilePath);
+      if (!existsSync(sourcePath)) {
+        continue;
+      }
+
+      try {
+        const content = readFileSync(sourcePath, "utf8");
+        for (const importName of extractExternalImports(content)) {
+          if (workspacePackageDirs.has(importName)) {
+            continue;
+          }
+          const resolvedVersion = packageDeps[importName] ?? rootDeps[importName];
+          if (resolvedVersion && !externalDeps[importName]) {
+            externalDeps[importName] = resolvedVersion;
+          }
+        }
+      } catch (error) {
+        warn(`Warning: could not scan ${sourcePath}:`, error);
+      }
+    }
+  }
+
+  return externalDeps;
+}
+
+function readManifestDependencies(
+  manifestPath: string,
+  warn: WarnFn
+): Record<string, string> {
+  if (!existsSync(manifestPath)) {
+    return {};
+  }
+
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const deps: Record<string, string> = {};
+    if (manifest.dependencies) {
+      for (const [name, version] of Object.entries(manifest.dependencies)) {
+        if (typeof version === "string" && !version.startsWith("workspace:")) {
+          deps[name] = version;
+        }
+      }
+    }
+    return deps;
+  } catch (error) {
+    warn(`Warning: could not read package.json at ${manifestPath}:`, error);
+    return {};
+  }
+}
+
+function listWorkspacePackageDirs(sourceDir: string): Set<string> {
+  const packagesDir = join(sourceDir, "..");
+  const workspaceDirs = new Set<string>();
+
+  for (const entry of readdirSync(packagesDir)) {
+    if (existsSync(join(packagesDir, entry, "package.json"))) {
+      workspaceDirs.add(entry);
+    }
+  }
+
+  return workspaceDirs;
+}
+
+function shouldInlineWorkspaceFile(relativeFilePath: string): boolean {
+  return (
+    relativeFilePath.endsWith(".ts") &&
+    !relativeFilePath.includes("node_modules/") &&
+    !relativeFilePath.endsWith(".test.ts") &&
+    !relativeFilePath.endsWith(".spec.ts") &&
+    !relativeFilePath.includes("package.json")
+  );
+}
+
+function resolveWorkspaceImport(args: {
+  packagesDir: string;
+  workspacePackageDirs: Set<string>;
+  importerPackageDir: string;
+  importerRelativeFilePath: string;
+  importPath: string;
+}): WorkspaceFileTarget | null {
+  const {
+    packagesDir,
+    workspacePackageDirs,
+    importerPackageDir,
+    importerRelativeFilePath,
+    importPath,
+  } = args;
+
+  if (importPath.startsWith("node:") || importPath.startsWith("/")) {
+    return null;
+  }
+
+  if (importPath.startsWith(".")) {
+    const importBase = join(
+      dirname(join(importerPackageDir, importerRelativeFilePath)),
+      importPath
+    );
+    return toWorkspaceFileTarget(
+      packagesDir,
+      workspacePackageDirs,
+      resolveImportAbsolutePath(importBase)
+    );
+  }
+
+  const packageName = extractPackageNameFromImportPath(importPath);
+  if (!workspacePackageDirs.has(packageName)) {
+    return null;
+  }
+
+  const subPath =
+    importPath === packageName ? "index" : importPath.slice(packageName.length + 1);
+  return toWorkspaceFileTarget(
+    packagesDir,
+    workspacePackageDirs,
+    resolveImportAbsolutePath(join(packagesDir, packageName, subPath))
+  );
+}
+
+function toWorkspaceFileTarget(
+  packagesDir: string,
+  workspacePackageDirs: Set<string>,
+  absoluteFilePath: string | null
+): WorkspaceFileTarget | null {
+  if (!absoluteFilePath) {
+    return null;
+  }
+
+  const relativeToPackages = relative(packagesDir, absoluteFilePath).replace(/\\/g, "/");
+  if (
+    relativeToPackages.startsWith("..") ||
+    relativeToPackages.length === 0
+  ) {
+    return null;
+  }
+
+  const [packageName, ...pathParts] = relativeToPackages.split("/");
+  if (!workspacePackageDirs.has(packageName) || pathParts.length === 0) {
+    return null;
+  }
+
+  return {
+    packageName,
+    relativeFilePath: pathParts.join("/"),
+  };
+}
+
+function resolveImportAbsolutePath(importBase: string): string | null {
+  const candidates = [
+    importBase,
+    `${importBase}.ts`,
+    `${importBase}.tsx`,
+    join(importBase, "index.ts"),
+    join(importBase, "index.tsx"),
+    `${importBase}.json`,
+  ];
+
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) {
+      continue;
+    }
+    const stat = statSync(candidate);
+    if (stat.isFile()) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function extractPackageNameFromImportPath(importPath: string): string {
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+
+  const firstSlash = importPath.indexOf("/");
+  return firstSlash === -1 ? importPath : importPath.slice(0, firstSlash);
+}
+
+function extractModuleSpecifiers(content: string): string[] {
+  const specifiers = new Set<string>();
+  const importOrExportRegex =
+    /(?:import|export)\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+  const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+  let match: RegExpExecArray | null;
+  while ((match = importOrExportRegex.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  while ((match = dynamicImportRegex.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  return Array.from(specifiers);
+}