@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/migrate/codemods/monorepo-catalog.js

@@ -1,517 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { multiselectPrompt } from "@reliverse/rempts";
-import { readPackageJSON } from "pkg-types";
-import semver from "semver";
-import { glob } from "tinyglobby";
-export function isCatalogReference(versionSpec) {
-  return versionSpec.startsWith("catalog:");
-}
-export function isWorkspaceDependency(versionSpec) {
-  return versionSpec.startsWith("workspace:");
-}
-export function isNpmAlias(versionSpec) {
-  return versionSpec.startsWith("npm:");
-}
-export function shouldSkipDependency(versionSpec) {
-  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
-}
-export async function findWorkspacePackageJsons(cwd) {
-  const root = await readPackageJSON(cwd);
-  const ws = root.workspaces;
-  let patterns = [];
-  if (Array.isArray(ws)) {
-    patterns = ws;
-  } else if (ws && Array.isArray(ws.packages)) {
-    patterns = ws.packages;
-  }
-  if (!patterns.length) return [];
-  const dirs = await glob(patterns, {
-    cwd,
-    onlyDirectories: true,
-    absolute: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-  });
-  const pkgJsonPaths = [];
-  for (const dir of dirs) {
-    const pj = path.join(dir, "package.json");
-    if (await fs.pathExists(pj)) pkgJsonPaths.push(pj);
-  }
-  return pkgJsonPaths;
-}
-export async function isMonorepo(cwd) {
-  try {
-    const root = await readPackageJSON(cwd);
-    const ws = root.workspaces;
-    if (Array.isArray(ws) && ws.length > 0) {
-      return true;
-    }
-    if (ws && Array.isArray(ws.packages) && ws.packages.length > 0) {
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-export function extractDependencies(packageJson, packageJsonPath) {
-  const dependencies = [];
-  const deps = packageJson.dependencies || {};
-  for (const [name, version] of Object.entries(deps)) {
-    if (typeof version === "string" && !shouldSkipDependency(version)) {
-      dependencies.push({
-        name,
-        version,
-        locations: /* @__PURE__ */ new Set(["dependencies"]),
-        packageJsonPath
-      });
-    }
-  }
-  const devDeps = packageJson.devDependencies || {};
-  for (const [name, version] of Object.entries(devDeps)) {
-    if (typeof version === "string" && !shouldSkipDependency(version)) {
-      const existing = dependencies.find((d) => d.name === name);
-      if (existing) {
-        existing.locations.add("devDependencies");
-        if (existing.locations.has("dependencies")) {
-          existing.version = deps[name] || existing.version;
-        }
-      } else {
-        dependencies.push({
-          name,
-          version,
-          locations: /* @__PURE__ */ new Set(["devDependencies"]),
-          packageJsonPath
-        });
-      }
-    }
-  }
-  return dependencies;
-}
-export function mergeToCatalog(existingCatalog, newDependencies) {
-  const result = {
-    added: [],
-    bumped: [],
-    skipped: []
-  };
-  for (const dep of newDependencies) {
-    const existingVersion = existingCatalog[dep.name];
-    if (!existingVersion) {
-      existingCatalog[dep.name] = dep.version;
-      result.added.push(dep);
-    } else {
-      try {
-        const cleanExisting = existingVersion.replace(/^[\^~]/, "");
-        const cleanNew = dep.version.replace(/^[\^~]/, "");
-        if (semver.valid(cleanExisting) && semver.valid(cleanNew)) {
-          if (semver.gt(cleanNew, cleanExisting)) {
-            existingCatalog[dep.name] = dep.version;
-            result.bumped.push({ ...dep, oldVersion: existingVersion });
-          } else {
-            result.skipped.push(dep);
-          }
-        } else {
-          result.skipped.push(dep);
-        }
-      } catch {
-        result.skipped.push(dep);
-      }
-    }
-  }
-  return result;
-}
-export async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesToReplace) {
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonContent);
-    let replacedCount = 0;
-    for (const dep of dependenciesToReplace) {
-      for (const location of dep.locations) {
-        if (location === "dependencies" && packageJson.dependencies?.[dep.name]) {
-          packageJson.dependencies[dep.name] = "catalog:";
-          replacedCount++;
-        } else if (location === "devDependencies" && packageJson.devDependencies?.[dep.name]) {
-          packageJson.devDependencies[dep.name] = "catalog:";
-          replacedCount++;
-        }
-      }
-    }
-    if (replacedCount > 0) {
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
-    }
-    return replacedCount;
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return 0;
-  }
-}
-export async function restoreCatalogReferences(packageJsonPath, catalog) {
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonContent);
-    let restoredCount = 0;
-    const deps = packageJson.dependencies || {};
-    for (const [name, version] of Object.entries(deps)) {
-      if (typeof version === "string" && isCatalogReference(version)) {
-        const catalogVersion = catalog[name];
-        if (catalogVersion && packageJson.dependencies) {
-          packageJson.dependencies[name] = catalogVersion;
-          restoredCount++;
-        } else {
-          relinka("warn", `No catalog entry found for dependency: ${name} in ${packageJsonPath}`);
-        }
-      }
-    }
-    const devDeps = packageJson.devDependencies || {};
-    for (const [name, version] of Object.entries(devDeps)) {
-      if (typeof version === "string" && isCatalogReference(version)) {
-        const catalogVersion = catalog[name];
-        if (catalogVersion && packageJson.devDependencies) {
-          packageJson.devDependencies[name] = catalogVersion;
-          restoredCount++;
-        } else {
-          relinka(
-            "warn",
-            `No catalog entry found for devDependency: ${name} in ${packageJsonPath}`
-          );
-        }
-      }
-    }
-    if (restoredCount > 0) {
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
-    }
-    return restoredCount;
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to restore ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return 0;
-  }
-}
-export async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
-  try {
-    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonContent);
-    if (!packageJson.workspaces) {
-      packageJson.workspaces = {};
-    }
-    if (Array.isArray(packageJson.workspaces)) {
-      packageJson.workspaces = { packages: packageJson.workspaces };
-    }
-    packageJson.workspaces.catalog = catalog;
-    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
-  } catch (error) {
-    throw new Error(
-      `Failed to update root package.json: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-export async function removeCatalogFromRoot(rootPackageJsonPath) {
-  try {
-    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonContent);
-    if (packageJson.workspaces && !Array.isArray(packageJson.workspaces) && packageJson.workspaces.catalog) {
-      packageJson.workspaces.catalog = void 0;
-      if (Object.keys(packageJson.workspaces).length === 0 || Object.keys(packageJson.workspaces).length === 1 && packageJson.workspaces.packages) {
-        if (!packageJson.workspaces.packages) {
-          packageJson.workspaces = void 0;
-        }
-      }
-    }
-    if (packageJson.catalog) {
-      packageJson.catalog = void 0;
-    }
-    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
-  } catch (error) {
-    throw new Error(
-      `Failed to remove catalog from root package.json: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-export async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
-  const results = [];
-  const workspacePaths = await findWorkspacePackageJsons(rootPath);
-  if (workspacePaths.length === 0) {
-    throw new Error("No workspace packages found. This command requires a monorepo setup.");
-  }
-  relinka("log", `Found ${workspacePaths.length} workspace packages`);
-  const allDependencies = [];
-  for (const workspacePath of workspacePaths) {
-    try {
-      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
-      const packageJson = JSON.parse(packageJsonContent);
-      const deps = extractDependencies(packageJson, workspacePath);
-      allDependencies.push(...deps);
-    } catch (error) {
-      relinka(
-        "warn",
-        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (allDependencies.length === 0) {
-    relinka("log", "No dependencies found to migrate to catalog");
-    return results;
-  }
-  relinka("log", `Found ${allDependencies.length} total dependency entries across workspaces`);
-  const rootPackageJsonPath = path.resolve(rootPath, "package.json");
-  let existingCatalog = {};
-  try {
-    const rootPackageJson = await readPackageJSON(rootPath);
-    existingCatalog = rootPackageJson.workspaces?.catalog || {};
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to read root package.json: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  const mergeResult = mergeToCatalog(existingCatalog, allDependencies);
-  relinka("log", `Catalog merge summary:`);
-  relinka("log", `  - ${mergeResult.added.length} new dependencies added`);
-  relinka("log", `  - ${mergeResult.bumped.length} dependencies bumped to newer versions`);
-  relinka(
-    "log",
-    `  - ${mergeResult.skipped.length} dependencies skipped (already up-to-date or incompatible)`
-  );
-  let dependenciesToMigrate = allDependencies;
-  if (interactive && allDependencies.length > 0) {
-    const selectedPackages = await multiselectPrompt({
-      title: "Select dependencies to migrate to catalog",
-      options: [
-        { label: "Migrate all dependencies", value: "all" },
-        { label: "Cancel migration", value: "cancel" },
-        ...Array.from(new Set(allDependencies.map((d) => d.name))).map((name) => ({
-          label: name,
-          value: name
-        }))
-      ]
-    });
-    if (selectedPackages.includes("cancel")) {
-      relinka("log", "Migration cancelled");
-      return results;
-    }
-    if (!selectedPackages.includes("all")) {
-      dependenciesToMigrate = allDependencies.filter((dep) => selectedPackages.includes(dep.name));
-    }
-  }
-  if (dryRun) {
-    relinka("log", "Dry run mode - no changes were made");
-    relinka("log", "Would migrate the following dependencies to catalog:");
-    const uniqueDeps = Array.from(new Set(dependenciesToMigrate.map((d) => d.name)));
-    for (const depName of uniqueDeps) {
-      const catalogVersion = existingCatalog[depName];
-      relinka("log", `  ${depName}: ${catalogVersion || "new entry"}`);
-    }
-    return results;
-  }
-  await updateRootWithCatalog(rootPackageJsonPath, existingCatalog);
-  const workspaceResults = /* @__PURE__ */ new Map();
-  for (const dep of dependenciesToMigrate) {
-    if (!workspaceResults.has(dep.packageJsonPath)) {
-      workspaceResults.set(dep.packageJsonPath, []);
-    }
-    workspaceResults.get(dep.packageJsonPath).push(dep);
-  }
-  for (const [packagePath, deps] of workspaceResults.entries()) {
-    const replacedCount = await replaceDependenciesWithCatalogRefs(packagePath, deps);
-    if (replacedCount > 0) {
-      relinka("log", `Updated ${replacedCount} dependencies in ${packagePath}`);
-      for (const dep of deps) {
-        results.push({
-          package: dep.name,
-          action: "replaced-with-catalog",
-          oldVersion: dep.version,
-          newVersion: "catalog:",
-          location: Array.from(dep.locations).join(", "),
-          packageJsonPath: packagePath
-        });
-      }
-    }
-  }
-  for (const dep of mergeResult.added) {
-    results.push({
-      package: dep.name,
-      action: "added-to-catalog",
-      newVersion: dep.version,
-      location: "catalog"
-    });
-  }
-  for (const dep of mergeResult.bumped) {
-    results.push({
-      package: dep.name,
-      action: "version-bumped",
-      oldVersion: dep.oldVersion,
-      newVersion: dep.version,
-      location: "catalog"
-    });
-  }
-  return results;
-}
-export async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = false, interactive = false) {
-  const results = [];
-  const rootPackageJson = await readPackageJSON(rootPath);
-  const catalog = rootPackageJson.workspaces?.catalog || {};
-  if (Object.keys(catalog).length === 0) {
-    relinka("warn", "No workspaces.catalog found in root package.json");
-    return results;
-  }
-  relinka("log", `Found catalog with ${Object.keys(catalog).length} entries`);
-  const workspacePaths = await findWorkspacePackageJsons(rootPath);
-  if (workspacePaths.length === 0) {
-    relinka("warn", "No workspace packages found");
-    return results;
-  }
-  const packagesWithCatalogRefs = [];
-  for (const workspacePath of workspacePaths) {
-    try {
-      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
-      const packageJson = JSON.parse(packageJsonContent);
-      const catalogRefs = [];
-      const deps = packageJson.dependencies || {};
-      for (const [name, version] of Object.entries(deps)) {
-        if (typeof version === "string" && isCatalogReference(version)) {
-          catalogRefs.push(name);
-        }
-      }
-      const devDeps = packageJson.devDependencies || {};
-      for (const [name, version] of Object.entries(devDeps)) {
-        if (typeof version === "string" && isCatalogReference(version)) {
-          catalogRefs.push(name);
-        }
-      }
-      if (catalogRefs.length > 0) {
-        packagesWithCatalogRefs.push({
-          path: workspacePath,
-          catalogRefs: [...new Set(catalogRefs)]
-          // Remove duplicates
-        });
-      }
-    } catch (error) {
-      relinka(
-        "warn",
-        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (packagesWithCatalogRefs.length === 0) {
-    relinka("log", "No catalog references found in workspace packages");
-    if (removeCatalog && !dryRun) {
-      const rootPackageJsonPath = path.resolve(rootPath, "package.json");
-      await removeCatalogFromRoot(rootPackageJsonPath);
-      relinka("log", "Removed catalog from root package.json");
-    }
-    return results;
-  }
-  const totalCatalogRefs = packagesWithCatalogRefs.reduce(
-    (sum, pkg) => sum + pkg.catalogRefs.length,
-    0
-  );
-  relinka(
-    "log",
-    `Found ${totalCatalogRefs} catalog references across ${packagesWithCatalogRefs.length} packages`
-  );
-  let packagesToProcess = packagesWithCatalogRefs;
-  if (interactive && packagesWithCatalogRefs.length > 0) {
-    const allCatalogRefs = Array.from(
-      new Set(packagesWithCatalogRefs.flatMap((p) => p.catalogRefs))
-    );
-    const selectedPackages = await multiselectPrompt({
-      title: "Select dependencies to restore from catalog",
-      options: [
-        { label: "Restore all catalog references", value: "all" },
-        { label: "Cancel restoration", value: "cancel" },
-        ...allCatalogRefs.map((name) => ({
-          label: `${name} (${catalog[name] || "missing in catalog"})`,
-          value: name,
-          disabled: !catalog[name]
-        }))
-      ]
-    });
-    if (selectedPackages.includes("cancel")) {
-      relinka("log", "Restoration cancelled");
-      return results;
-    }
-    if (!selectedPackages.includes("all")) {
-      packagesToProcess = packagesWithCatalogRefs.map((pkg) => ({
-        ...pkg,
-        catalogRefs: pkg.catalogRefs.filter((ref) => selectedPackages.includes(ref))
-      })).filter((pkg) => pkg.catalogRefs.length > 0);
-    }
-  }
-  if (dryRun) {
-    relinka("log", "Dry run mode - no changes were made");
-    relinka("log", "Would restore the following catalog references:");
-    for (const pkg of packagesToProcess) {
-      relinka("log", `  ${pkg.path}:`);
-      for (const ref of pkg.catalogRefs) {
-        const catalogVersion = catalog[ref];
-        relinka("log", `    ${ref}: catalog: \u2192 ${catalogVersion || "MISSING"}`);
-      }
-    }
-    if (removeCatalog) {
-      relinka("log", "Would also remove workspaces.catalog from root package.json");
-    }
-    return results;
-  }
-  for (const pkg of packagesToProcess) {
-    const restoredCount = await restoreCatalogReferences(pkg.path, catalog);
-    if (restoredCount > 0) {
-      relinka("log", `Restored ${restoredCount} catalog references in ${pkg.path}`);
-      for (const ref of pkg.catalogRefs) {
-        if (catalog[ref]) {
-          results.push({
-            package: ref,
-            action: "restored-from-catalog",
-            oldVersion: "catalog:",
-            newVersion: catalog[ref],
-            location: "dependencies/devDependencies",
-            packageJsonPath: pkg.path
-          });
-        }
-      }
-    }
-  }
-  if (removeCatalog) {
-    const rootPackageJsonPath = path.resolve(rootPath, "package.json");
-    await removeCatalogFromRoot(rootPackageJsonPath);
-    relinka("log", "Removed workspaces.catalog from root package.json");
-  }
-  return results;
-}
-export function displayMigrationResults(results) {
-  if (results.length === 0) {
-    relinka("log", "No changes were made");
-    return;
-  }
-  const byAction = results.reduce(
-    (acc, result) => {
-      if (!acc[result.action]) acc[result.action] = [];
-      acc[result.action].push(result);
-      return acc;
-    },
-    {}
-  );
-  for (const [action, actionResults] of Object.entries(byAction)) {
-    relinka("log", `
-${action.replace(/-/g, " ")} (${actionResults.length}):`);
-    for (const result of actionResults) {
-      let message = `  ${result.package}`;
-      if (result.oldVersion && result.newVersion) {
-        message += `: ${result.oldVersion} \u2192 ${result.newVersion}`;
-      } else if (result.newVersion) {
-        message += `: ${result.newVersion}`;
-      }
-      if (result.packageJsonPath) {
-        message += ` (${result.packageJsonPath})`;
-      }
-      relinka("log", message);
-    }
-  }
-  relinka("success", `Migration completed: ${results.length} changes made`);
-  relinka("log", "Run your package manager install command to apply the changes");
-}

package/bin/impl/migrate/codemods/nodenext-bundler.d.ts

@@ -1,10 +0,0 @@
-interface MigrationResult {
-    file: string;
-    success: boolean;
-    message: string;
-    changes?: string[];
-}
-export declare function migrateToNodeNext(dryRun?: boolean): Promise<MigrationResult[]>;
-export declare function migrateToBundler(dryRun?: boolean): Promise<MigrationResult[]>;
-export declare function migrateModuleResolution(target: "nodenext" | "bundler", dryRun?: boolean): Promise<MigrationResult[]>;
-export {};