nolo-cli 0.1.26 → 0.1.29

package/buildPublishArtifactAssembly.ts

@@ -0,0 +1,346 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, relative } from "node:path";
+import {
+  collectTypeScriptSourceFiles,
+  findTypeScriptFiles,
+} from "./buildPublishImportAnalysis";
+
+type WarnFn = (message: string, error?: unknown) => void;
+
+export type InlineWorkspaceDependenciesOptions = {
+  sourceDir: string;
+  distDir: string;
+  workspaceDeps: string[];
+  extractExternalImports: (content: string) => string[];
+  rewriteCrossPackageImports: (
+    content: string,
+    workspaceDeps: string[],
+    relativeFilePath: string
+  ) => string;
+  warn: WarnFn;
+};
+
+export type BuildPublishArtifactAssemblyOptions = {
+  sourceDir: string;
+  distDir: string;
+  filesToCopy: string[];
+  extractExternalImports: (content: string) => string[];
+  rewriteCrossPackageImports: (
+    content: string,
+    workspaceDeps: string[],
+    relativeFilePath: string
+  ) => string;
+  collectWorkspaceDependencies: (
+    sourceDir: string,
+    filesToCopy: string[]
+  ) => string[];
+  inlineWorkspaceDependencies: (
+    options: InlineWorkspaceDependenciesOptions
+  ) => Promise<{ inlinedDeps: string[]; externalDeps: Record<string, string> }>;
+  warn: WarnFn;
+};
+
+export async function buildPublishArtifactAssembly(
+  options: BuildPublishArtifactAssemblyOptions
+): Promise<{
+  resolvedFilesToCopy: string[];
+  workspaceDeps: string[];
+  inlinedDeps: string[];
+  externalDeps: Record<string, string>;
+}> {
+  const {
+    sourceDir,
+    distDir,
+    filesToCopy,
+    extractExternalImports,
+    rewriteCrossPackageImports,
+    collectWorkspaceDependencies,
+    inlineWorkspaceDependencies,
+    warn,
+  } = options;
+
+  rmSync(distDir, { recursive: true, force: true });
+  mkdirSync(distDir, { recursive: true });
+
+  const resolvedFilesToCopy = resolveFilesToCopy(sourceDir, filesToCopy);
+  const workspaceDeps = collectWorkspaceDependencies(sourceDir, resolvedFilesToCopy);
+
+  for (const file of resolvedFilesToCopy) {
+    const sourcePath = join(sourceDir, file);
+    const destPath = join(distDir, file);
+
+    if (!existsSync(sourcePath)) {
+      warn(`Warning: file not found: ${sourcePath}`);
+      continue;
+    }
+
+    const destDir = dirname(destPath);
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    if (file.endsWith(".ts")) {
+      const content = readFileSync(sourcePath, "utf8");
+      const rewritten = rewriteCrossPackageImports(content, workspaceDeps, file);
+      writeFileSync(destPath, rewritten);
+    } else {
+      copyFileSync(sourcePath, destPath);
+    }
+  }
+
+  const { inlinedDeps, externalDeps } = await inlineWorkspaceDependencies({
+    sourceDir,
+    distDir,
+    workspaceDeps,
+    extractExternalImports,
+    rewriteCrossPackageImports,
+    warn,
+  });
+
+  return { resolvedFilesToCopy, workspaceDeps, inlinedDeps, externalDeps };
+}
+
+export async function inlineWorkspaceDependencies(
+  options: InlineWorkspaceDependenciesOptions
+): Promise<{ inlinedDeps: string[]; externalDeps: Record<string, string> }> {
+  const {
+    sourceDir,
+    distDir,
+    workspaceDeps,
+    extractExternalImports,
+    rewriteCrossPackageImports,
+    warn,
+  } = options;
+  if (workspaceDeps.length === 0) {
+    return { inlinedDeps: [], externalDeps: {} };
+  }
+
+  const packagesDir = join(sourceDir, "..");
+  const repoRoot = join(packagesDir, "..");
+  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 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);
+      }
+    }
+
+    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);
+      }
+    }
+
+    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);
+      }
+    }
+  }
+
+  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
+        );
+        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);
+      }
+    }
+  }
+
+  return { inlinedDeps, externalDeps };
+}
+
+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 [];
+  }
+
+  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);
+      }
+    }
+  }
+
+  return Array.from(discovered);
+}
+
+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> = {};
+
+  if (rootManifest.dependencies) {
+    for (const [name, version] of Object.entries(rootManifest.dependencies)) {
+      if (typeof version === "string" && !version.startsWith("workspace:")) {
+        rootDeps[name] = version;
+      }
+    }
+  }
+
+  for (const depName of inlinedDeps) {
+    const depDir = join(distDir, depName);
+    if (!existsSync(depDir)) {
+      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);
+      }
+    }
+  }
+
+  return externalDeps;
+}
+
+export { collectTypeScriptSourceFiles, findTypeScriptFiles };
+
+export function resolveFilesToCopy(sourceDir: string, filesToCopy: string[]): string[] {
+  const resolved = new Set<string>();
+
+  for (const entry of filesToCopy) {
+    if (entry.endsWith("/**/*.ts")) {
+      const baseDir = entry.slice(0, -"/**/*.ts".length);
+      const absoluteBaseDir = join(sourceDir, baseDir);
+      if (!existsSync(absoluteBaseDir)) {
+        continue;
+      }
+      for (const filePath of findTypeScriptFiles(absoluteBaseDir)) {
+        resolved.add(relative(sourceDir, filePath));
+      }
+      continue;
+    }
+
+    resolved.add(entry);
+  }
+
+  return Array.from(resolved);
+}
+
+export function copyDirectory(
+  src: string,
+  dest: string,
+  filter?: (file: string) => boolean,
+  transform?: (file: string, content: string) => string
+): void {
+  if (!existsSync(src)) {
+    return;
+  }
+
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      copyDirectory(srcPath, destPath, filter, transform);
+    } else if (stat.isFile() && (!filter || filter(srcPath))) {
+      const parentDir = dirname(destPath);
+      if (!existsSync(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+      }
+      if (transform && srcPath.endsWith(".ts")) {
+        writeFileSync(destPath, transform(srcPath, readFileSync(srcPath, "utf8")));
+      } else {
+        copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}

package/buildPublishImportAnalysis.ts

@@ -0,0 +1,237 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+
+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);
+}
+
+export function extractExternalImports(content: string): string[] {
+  const imports = new Set<string>();
+  const importRegex =
+    /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+  const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+  let match: RegExpExecArray | null;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[1];
+    if (
+      importPath.startsWith(".") ||
+      importPath.startsWith("node:") ||
+      importPath.startsWith("/")
+    ) {
+      continue;
+    }
+    imports.add(extractPackageNameFromImportPath(importPath));
+  }
+
+  while ((match = dynamicImportRegex.exec(content)) !== null) {
+    const importPath = match[1];
+    if (
+      importPath.startsWith(".") ||
+      importPath.startsWith("node:") ||
+      importPath.startsWith("/")
+    ) {
+      continue;
+    }
+    imports.add(extractPackageNameFromImportPath(importPath));
+  }
+
+  return Array.from(imports);
+}
+
+export function extractWorkspaceDependencies(
+  manifest: Record<string, any>
+): string[] {
+  const deps: string[] = [];
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (!manifest[field]) {
+      continue;
+    }
+    for (const [name, version] of Object.entries(manifest[field])) {
+      if (typeof version === "string" && version.startsWith("workspace:")) {
+        deps.push(name);
+      }
+    }
+  }
+  return deps;
+}
+
+export function findSiblingWorkspacePackageNames(sourceDir: string): string[] {
+  const packagesDir = join(sourceDir, "..");
+  const names: string[] = [];
+
+  for (const entry of readdirSync(packagesDir)) {
+    const pkgPath = join(packagesDir, entry, "package.json");
+    if (!existsSync(pkgPath)) {
+      continue;
+    }
+    try {
+      const manifest = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (typeof manifest.name === "string" && manifest.name.length > 0) {
+        names.push(manifest.name);
+      }
+    } catch {
+      // Ignore malformed sibling manifests while scanning workspace package names.
+    }
+  }
+
+  return names;
+}
+
+export function extractWorkspaceImports(
+  content: string,
+  workspacePackageNames: Set<string>
+): string[] {
+  const imports = new Set<string>();
+
+  for (const packageName of extractExternalImports(content)) {
+    if (workspacePackageNames.has(packageName)) {
+      imports.add(packageName);
+    }
+  }
+
+  const relativeWorkspaceImportRegex =
+    /(?:from\s+['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]|import\(\s*['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]\s*\))/g;
+
+  let match: RegExpExecArray | null;
+  while ((match = relativeWorkspaceImportRegex.exec(content)) !== null) {
+    const packageName = match[1] || match[2];
+    if (packageName && workspacePackageNames.has(packageName)) {
+      imports.add(packageName);
+    }
+  }
+
+  return Array.from(imports);
+}
+
+export function collectWorkspaceDependencies(
+  sourceDir: string,
+  manifest: Record<string, any>,
+  filesToCopy: string[]
+): string[] {
+  const workspaceDeps = new Set(extractWorkspaceDependencies(manifest));
+  const workspacePackageNames = new Set(findSiblingWorkspacePackageNames(sourceDir));
+
+  for (const filePath of collectTypeScriptSourceFiles(sourceDir, filesToCopy)) {
+    const content = readFileSync(filePath, "utf8");
+    for (const dep of extractWorkspaceImports(content, workspacePackageNames)) {
+      workspaceDeps.add(dep);
+    }
+  }
+
+  return Array.from(workspaceDeps);
+}
+
+export function findTypeScriptFiles(dir: string): string[] {
+  const files: string[] = [];
+
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...findTypeScriptFiles(fullPath));
+      continue;
+    }
+    if (stat.isFile() && fullPath.endsWith(".ts")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+export function collectTypeScriptSourceFiles(
+  sourceDir: string,
+  filesToCopy: string[]
+): string[] {
+  const files: string[] = [];
+
+  for (const entry of filesToCopy) {
+    const sourcePath = join(sourceDir, entry);
+    if (!existsSync(sourcePath)) {
+      continue;
+    }
+    const stat = statSync(sourcePath);
+    if (stat.isDirectory()) {
+      files.push(...findTypeScriptFiles(sourcePath));
+      continue;
+    }
+    if (stat.isFile() && sourcePath.endsWith(".ts")) {
+      files.push(sourcePath);
+    }
+  }
+
+  return files;
+}
+
+function escapeRegex(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function createWorkspaceSpecifier(relativeFilePath: string, packageName: string, path = ""): string {
+  const fileDir = dirname(relativeFilePath);
+  const relativePackagePath = relative(fileDir === "." ? "" : fileDir, packageName).replace(
+    /\\/g,
+    "/"
+  );
+  const prefix = relativePackagePath.startsWith(".")
+    ? relativePackagePath
+    : `./${relativePackagePath}`;
+  return `${prefix}${path}`;
+}
+
+export function rewriteCrossPackageImports(
+  content: string,
+  workspaceDeps: string[],
+  relativeFilePath = ""
+): string {
+  if (workspaceDeps.length === 0) {
+    return content;
+  }
+
+  const patterns = workspaceDeps.map(escapeRegex);
+  const relativeDepth =
+    dirname(relativeFilePath) === "."
+      ? 1
+      : dirname(relativeFilePath).split(/[\\/]/).filter(Boolean).length + 1;
+  const crossPackagePrefixPattern = `(?:\\.\\./){${relativeDepth}}`;
+
+  const relativeImportRegex = new RegExp(
+    `(from\\s+['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"])`,
+    "g"
+  );
+  const bareImportRegex = new RegExp(
+    `(from\\s+['"])(${patterns.join("|")})(/[^'"]*)?(['"])`,
+    "g"
+  );
+  const dynamicRelativeImportRegex = new RegExp(
+    `(import\\(\\s*['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
+    "g"
+  );
+  const dynamicBareImportRegex = new RegExp(
+    `(import\\(\\s*['"])(${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
+    "g"
+  );
+
+  let result = content;
+  result = result.replace(relativeImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(bareImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(dynamicRelativeImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(dynamicBareImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+
+  return result;
+}