@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/utils/pm/pm-catalog.js

@@ -1,237 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON } from "pkg-types";
-export async function getCatalogStructure(cwd = process.cwd()) {
-  try {
-    const packageJson = await readPackageJSON(cwd);
-    const workspaces = packageJson.workspaces || {};
-    return {
-      catalog: workspaces.catalog || packageJson.catalog || {},
-      catalogs: workspaces.catalogs || packageJson.catalogs || {}
-    };
-  } catch (error) {
-    relinka("warn", `Failed to read catalog structure: ${error}`);
-    return { catalog: {}, catalogs: {} };
-  }
-}
-export async function addToCatalog(dependencies, catalogType, catalogName, cwd = process.cwd()) {
-  try {
-    const packageJsonPath = path.resolve(cwd, "package.json");
-    const packageJson = await readPackageJSON(cwd);
-    const latestVersions = {};
-    for (const dep of dependencies) {
-      try {
-        const packageName = dep.split("@")[0] || dep;
-        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
-        if (response.ok) {
-          const data = await response.json();
-          latestVersions[packageName] = `^${data.version}`;
-        } else {
-          latestVersions[packageName] = "latest";
-        }
-      } catch (error) {
-        relinka("warn", `Failed to get latest version for ${dep}: ${error}`);
-        latestVersions[dep] = "latest";
-      }
-    }
-    const updatedPackageJson = { ...packageJson };
-    if (catalogType === "catalog") {
-      if (!updatedPackageJson.workspaces) {
-        updatedPackageJson.workspaces = {};
-      }
-      if (!updatedPackageJson.workspaces.catalog) {
-        updatedPackageJson.workspaces.catalog = {};
-      }
-      Object.assign(updatedPackageJson.workspaces.catalog, latestVersions);
-      if (updatedPackageJson.catalog) {
-        Object.assign(updatedPackageJson.catalog, latestVersions);
-      }
-    } else if (catalogType === "catalogs" && catalogName) {
-      if (!updatedPackageJson.workspaces) {
-        updatedPackageJson.workspaces = {};
-      }
-      if (!updatedPackageJson.workspaces.catalogs) {
-        updatedPackageJson.workspaces.catalogs = {};
-      }
-      if (!updatedPackageJson.workspaces.catalogs[catalogName]) {
-        updatedPackageJson.workspaces.catalogs[catalogName] = {};
-      }
-      Object.assign(updatedPackageJson.workspaces.catalogs[catalogName], latestVersions);
-      if (updatedPackageJson.catalogs) {
-        if (!updatedPackageJson.catalogs[catalogName]) {
-          updatedPackageJson.catalogs[catalogName] = {};
-        }
-        Object.assign(updatedPackageJson.catalogs[catalogName], latestVersions);
-      }
-    }
-    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
-    relinka(
-      "success",
-      `Added ${dependencies.length} dependencies to ${catalogType}${catalogName ? ` (${catalogName})` : ""}`
-    );
-  } catch (error) {
-    relinka("error", `Failed to add dependencies to catalog: ${error}`);
-    throw error;
-  }
-}
-export function isCatalogSupported(packageManager) {
-  return packageManager.name === "bun";
-}
-export function getCatalogReference(dependency, catalogType, catalogName) {
-  if (catalogType === "catalog") {
-    return "catalog:";
-  } else if (catalogType === "catalogs" && catalogName) {
-    return `catalog:${catalogName}`;
-  }
-  return dependency;
-}
-export async function listCatalogs(cwd = process.cwd()) {
-  try {
-    const { catalog, catalogs } = await getCatalogStructure(cwd);
-    if ((!catalog || Object.keys(catalog).length === 0) && (!catalogs || Object.keys(catalogs).length === 0)) {
-      relinka("info", "No catalogs found in package.json");
-      return;
-    }
-    if (catalog && Object.keys(catalog).length > 0) {
-      relinka("info", "Default catalog:");
-      for (const [dep, version] of Object.entries(catalog)) {
-        relinka("verbose", `  ${dep}: ${version}`);
-      }
-    }
-    if (catalogs && Object.keys(catalogs).length > 0) {
-      for (const [catalogName, dependencies] of Object.entries(catalogs)) {
-        relinka("info", `
-Catalog '${catalogName}':`);
-        for (const [dep, version] of Object.entries(dependencies)) {
-          relinka("verbose", `  ${dep}: ${version}`);
-        }
-      }
-    }
-  } catch (error) {
-    relinka("error", `Failed to list catalogs: ${error}`);
-  }
-}
-export async function updateCatalogs(cwd = process.cwd()) {
-  try {
-    const { catalog, catalogs } = await getCatalogStructure(cwd);
-    const packageJsonPath = path.resolve(cwd, "package.json");
-    const packageJson = await readPackageJSON(cwd);
-    const updatedPackageJson = { ...packageJson };
-    let updatedCount = 0;
-    if (catalog && Object.keys(catalog).length > 0) {
-      const updatedCatalog = {};
-      for (const [dep, currentVersion] of Object.entries(catalog)) {
-        try {
-          const response = await fetch(`https://registry.npmjs.org/${dep}/latest`);
-          if (response.ok) {
-            const data = await response.json();
-            const latestVersion = `^${data.version}`;
-            if (latestVersion !== currentVersion) {
-              updatedCatalog[dep] = latestVersion;
-              updatedCount++;
-              relinka("verbose", `  ${dep}: ${currentVersion} \u2192 ${latestVersion}`);
-            } else {
-              updatedCatalog[dep] = currentVersion;
-            }
-          } else {
-            updatedCatalog[dep] = currentVersion;
-          }
-        } catch (error) {
-          relinka("warn", `Failed to update ${dep}: ${error}`);
-          updatedCatalog[dep] = currentVersion;
-        }
-      }
-      if (!updatedPackageJson.workspaces) {
-        updatedPackageJson.workspaces = {};
-      }
-      updatedPackageJson.workspaces.catalog = updatedCatalog;
-      if (updatedPackageJson.catalog) {
-        updatedPackageJson.catalog = updatedCatalog;
-      }
-    }
-    if (catalogs && Object.keys(catalogs).length > 0) {
-      if (!updatedPackageJson.workspaces) {
-        updatedPackageJson.workspaces = {};
-      }
-      if (!updatedPackageJson.workspaces.catalogs) {
-        updatedPackageJson.workspaces.catalogs = {};
-      }
-      for (const [catalogName, dependencies] of Object.entries(catalogs)) {
-        const updatedNamedCatalog = {};
-        for (const [dep, currentVersion] of Object.entries(dependencies)) {
-          try {
-            const response = await fetch(`https://registry.npmjs.org/${dep}/latest`);
-            if (response.ok) {
-              const data = await response.json();
-              const latestVersion = `^${data.version}`;
-              if (latestVersion !== currentVersion) {
-                updatedNamedCatalog[dep] = latestVersion;
-                updatedCount++;
-                relinka("verbose", `  ${catalogName}:${dep}: ${currentVersion} \u2192 ${latestVersion}`);
-              } else {
-                updatedNamedCatalog[dep] = currentVersion;
-              }
-            } else {
-              updatedNamedCatalog[dep] = currentVersion;
-            }
-          } catch (error) {
-            relinka("warn", `Failed to update ${catalogName}:${dep}: ${error}`);
-            updatedNamedCatalog[dep] = currentVersion;
-          }
-        }
-        updatedPackageJson.workspaces.catalogs[catalogName] = updatedNamedCatalog;
-        if (updatedPackageJson.catalogs) {
-          updatedPackageJson.catalogs[catalogName] = updatedNamedCatalog;
-        }
-      }
-    }
-    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
-    if (updatedCount > 0) {
-      relinka("success", `Updated ${updatedCount} catalog dependencies`);
-    } else {
-      relinka("success", "All catalog dependencies are up to date");
-    }
-  } catch (error) {
-    relinka("error", `Failed to update catalogs: ${error}`);
-    throw error;
-  }
-}
-export async function removeFromCatalog(dependencies, catalogType, catalogName, cwd = process.cwd()) {
-  try {
-    const packageJsonPath = path.resolve(cwd, "package.json");
-    const packageJson = await readPackageJSON(cwd);
-    const updatedPackageJson = { ...packageJson };
-    if (catalogType === "catalog") {
-      if (updatedPackageJson.workspaces?.catalog) {
-        for (const dep of dependencies) {
-          delete updatedPackageJson.workspaces.catalog[dep];
-        }
-      }
-      if (updatedPackageJson.catalog) {
-        for (const dep of dependencies) {
-          delete updatedPackageJson.catalog[dep];
-        }
-      }
-    } else if (catalogType === "catalogs" && catalogName) {
-      if (updatedPackageJson.workspaces?.catalogs?.[catalogName]) {
-        for (const dep of dependencies) {
-          delete updatedPackageJson.workspaces.catalogs[catalogName][dep];
-        }
-      }
-      if (updatedPackageJson.catalogs?.[catalogName]) {
-        for (const dep of dependencies) {
-          delete updatedPackageJson.catalogs[catalogName][dep];
-        }
-      }
-    }
-    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
-    relinka(
-      "success",
-      `Removed ${dependencies.length} dependencies from ${catalogType}${catalogName ? ` (${catalogName})` : ""}`
-    );
-  } catch (error) {
-    relinka("error", `Failed to remove dependencies from catalog: ${error}`);
-    throw error;
-  }
-}

package/bin/impl/utils/pm/pm-detect.d.ts

@@ -1,12 +0,0 @@
-import type { DetectPackageManagerOptions, PackageManager } from "./pm-types";
-export declare const packageManagers: PackageManager[];
-/**
- * Detect the package manager used in a directory (and up) by checking various sources:
- *
- * 1. Use `packageManager` field from package.json
- *
- * 2. Known lock files and other files
- */
-export declare function detectPackageManager(cwd: string, options?: DetectPackageManagerOptions): Promise<(PackageManager & {
-    warnings?: string[];
-}) | undefined>;

package/bin/impl/utils/pm/pm-detect.js

@@ -1,99 +0,0 @@
-import { join, resolve } from "@reliverse/pathkit";
-import { existsSync, readFile } from "@reliverse/relifso";
-import { findup, parsePackageManagerField } from "./pm-parse.js";
-export const packageManagers = [
-  {
-    name: "npm",
-    command: "npm",
-    lockFile: "package-lock.json"
-  },
-  {
-    name: "pnpm",
-    command: "pnpm",
-    lockFile: "pnpm-lock.yaml",
-    files: ["pnpm-workspace.yaml"]
-  },
-  {
-    name: "bun",
-    command: "bun",
-    lockFile: ["bun.lockb", "bun.lock"]
-  },
-  {
-    name: "yarn",
-    command: "yarn",
-    lockFile: "yarn.lock",
-    files: [".yarnrc.yml"]
-  },
-  {
-    name: "deno",
-    command: "deno",
-    lockFile: "deno.lock",
-    files: ["deno.json"]
-  }
-];
-export async function detectPackageManager(cwd, options = {}) {
-  const detected = await findup(
-    resolve(cwd || "."),
-    async (path) => {
-      if (!options.ignorePackageJSON) {
-        const packageJSONPath = join(path, "package.json");
-        if (existsSync(packageJSONPath)) {
-          const packageJSON = JSON.parse(await readFile(packageJSONPath, "utf8"));
-          if (packageJSON?.packageManager) {
-            const {
-              name,
-              version = "0.0.0",
-              buildMeta,
-              warnings
-            } = parsePackageManagerField(packageJSON.packageManager);
-            if (name) {
-              const majorVersion = version.split(".")[0];
-              const packageManager = packageManagers.find(
-                (pm) => pm.name === name && pm.majorVersion === majorVersion
-              ) || packageManagers.find((pm) => pm.name === name);
-              return {
-                name,
-                command: name,
-                version,
-                majorVersion,
-                buildMeta,
-                warnings,
-                files: packageManager?.files,
-                lockFile: packageManager?.lockFile
-              };
-            }
-          }
-        }
-        const denoJSONPath = join(path, "deno.json");
-        if (existsSync(denoJSONPath)) {
-          return packageManagers.find((pm) => pm.name === "deno");
-        }
-      }
-      if (!options.ignoreLockFile) {
-        for (const packageManager of packageManagers) {
-          const detectionsFiles = [packageManager.lockFile, packageManager.files].flat().filter(Boolean);
-          if (detectionsFiles.some((file) => existsSync(resolve(path, file)))) {
-            return {
-              ...packageManager
-            };
-          }
-        }
-      }
-    },
-    {
-      includeParentDirs: options.includeParentDirs ?? true
-    }
-  );
-  if (!detected && !options.ignoreArgv) {
-    const scriptArg = process.argv[1];
-    if (scriptArg) {
-      for (const packageManager of packageManagers) {
-        const re = new RegExp(`[/\\\\]\\.?${packageManager.command}`);
-        if (re.test(scriptArg)) {
-          return packageManager;
-        }
-      }
-    }
-  }
-  return detected;
-}

package/bin/impl/utils/pm/pm-meta.d.ts

@@ -1,27 +0,0 @@
-interface PackageJsonOptions {
-    version?: string;
-    omitDeprecated?: boolean;
-    registryUrl?: string;
-    fullMetadata?: boolean;
-    allVersions?: boolean;
-}
-interface PackageData {
-    "dist-tags": Record<string, string>;
-    versions: Record<string, PackageVersion>;
-    time?: Record<string, string>;
-}
-interface PackageVersion {
-    version: string;
-    deprecated?: boolean;
-    time?: Record<string, string>;
-    [key: string]: any;
-}
-export declare class PackageNotFoundError extends Error {
-    constructor(packageName: string);
-}
-export declare class VersionNotFoundError extends Error {
-    constructor(packageName: string, version: string);
-}
-export declare function pmPackageJson(packageName: string, options?: PackageJsonOptions): Promise<PackageData | PackageVersion>;
-export declare function latestVersion(packageName: string, options?: PackageJsonOptions): Promise<string>;
-export {};

package/bin/impl/utils/pm/pm-meta.js

@@ -1,86 +0,0 @@
-import ky from "ky";
-import registryAuthToken from "registry-auth-token";
-import registryUrl from "registry-url";
-import semver from "semver";
-export class PackageNotFoundError extends Error {
-  constructor(packageName) {
-    super(`Package \`${packageName}\` could not be found`);
-    this.name = "PackageNotFoundError";
-  }
-}
-export class VersionNotFoundError extends Error {
-  constructor(packageName, version) {
-    super(`Version \`${version}\` for package \`${packageName}\` could not be found`);
-    this.name = "VersionNotFoundError";
-  }
-}
-export async function pmPackageJson(packageName, options = {}) {
-  let { version = "latest" } = options;
-  const { omitDeprecated = true } = options;
-  const scope = packageName.split("/")[0];
-  const registryUrl_ = options.registryUrl ?? registryUrl(scope);
-  const packageUrl = new URL(encodeURIComponent(packageName).replace(/^%40/, "@"), registryUrl_);
-  const authInfo = registryAuthToken(registryUrl_.toString(), { recursive: true });
-  const headers = {
-    accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
-  };
-  if (options.fullMetadata) {
-    headers.accept = "";
-  }
-  if (authInfo) {
-    headers.authorization = `${authInfo.type} ${authInfo.token}`;
-  }
-  let data;
-  try {
-    data = await ky(packageUrl, { headers, keepalive: true }).json();
-  } catch (error) {
-    if (error?.response?.status === 404) {
-      throw new PackageNotFoundError(packageName);
-    }
-    throw error;
-  }
-  if (options.allVersions) {
-    return data;
-  }
-  const versionError = new VersionNotFoundError(packageName, version);
-  if (version && data["dist-tags"][version]) {
-    const { time } = data;
-    const versionTag = data["dist-tags"][version];
-    if (versionTag) {
-      const packageVersion = data.versions[versionTag];
-      if (packageVersion) {
-        packageVersion.time = time;
-        return packageVersion;
-      }
-    }
-  } else if (version) {
-    const versionExists = Boolean(data.versions[version]);
-    if (omitDeprecated && !versionExists) {
-      for (const [metadataVersion, metadata] of Object.entries(data.versions)) {
-        if (metadata.deprecated) {
-          delete data.versions[metadataVersion];
-        }
-      }
-    }
-    if (!versionExists) {
-      const versions = Object.keys(data.versions);
-      const resolvedVersion = semver.maxSatisfying(versions, version);
-      if (!resolvedVersion) {
-        throw versionError;
-      }
-      version = resolvedVersion;
-    }
-    const { time } = data;
-    const packageVersion = data.versions[version];
-    if (!packageVersion) {
-      throw versionError;
-    }
-    packageVersion.time = time;
-    return packageVersion;
-  }
-  throw versionError;
-}
-export async function latestVersion(packageName, options = {}) {
-  const { version } = await pmPackageJson(packageName.toLowerCase(), options);
-  return version;
-}

package/bin/impl/utils/pm/pm-parse.d.ts

@@ -1,8 +0,0 @@
-import type { DetectPackageManagerOptions, PackageManagerName } from "./pm-types";
-export declare function findup<T>(cwd: string, match: (path: string) => T | Promise<T>, options?: Pick<DetectPackageManagerOptions, "includeParentDirs">): Promise<T | undefined>;
-export declare function parsePackageManagerField(packageManager?: string): {
-    name?: PackageManagerName;
-    version?: string;
-    buildMeta?: string;
-    warnings?: string[];
-};

package/bin/impl/utils/pm/pm-parse.js

@@ -1,29 +0,0 @@
-import { normalize } from "@reliverse/pathkit";
-export async function findup(cwd, match, options = {}) {
-  const segments = normalize(cwd).split("/");
-  while (segments.length > 0) {
-    const path = segments.join("/") || "/";
-    const result = await match(path);
-    if (result || !options.includeParentDirs) {
-      return result;
-    }
-    segments.pop();
-  }
-}
-export function parsePackageManagerField(packageManager) {
-  const [name, _version] = (packageManager || "").split("@");
-  const [version, buildMeta] = _version?.split("+") || [];
-  if (name && name !== "-" && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) {
-    return { name, version, buildMeta };
-  }
-  const sanitized = name?.replace(/\W+/g, "") || "";
-  const warnings = [
-    `Abnormal characters found in \`packageManager\` field, sanitizing from \`${name}\` to \`${sanitized}\``
-  ];
-  return {
-    name: sanitized,
-    version,
-    buildMeta,
-    warnings
-  };
-}

package/bin/impl/utils/pm/pm-types.d.ts

@@ -1,46 +0,0 @@
-export type PackageManagerName = "npm" | "yarn" | "pnpm" | "bun" | "deno";
-export interface PackageManager {
-    name: PackageManagerName;
-    command: string;
-    version?: string;
-    buildMeta?: string;
-    majorVersion?: string;
-    lockFile?: string | string[];
-    files?: string[];
-}
-export interface OperationOptions {
-    cwd?: string;
-    silent?: boolean;
-    packageManager?: PackageManager | PackageManagerName;
-    installPeerDependencies?: boolean;
-    dev?: boolean;
-    workspace?: boolean | string;
-    global?: boolean;
-    filter?: string[];
-    asCatalog?: string;
-    catalogName?: string;
-}
-export interface DetectPackageManagerOptions {
-    /**
-     * Whether to ignore the lock file
-     *
-     * @default false
-     */
-    ignoreLockFile?: boolean;
-    /**
-     * Whether to ignore the package.json file
-     *
-     * @default false
-     */
-    ignorePackageJSON?: boolean;
-    /**
-     * Whether to include parent directories
-     *
-     * @default false
-     */
-    includeParentDirs?: boolean;
-    /**
-     * Weather to ignore argv[1] to detect script
-     */
-    ignoreArgv?: boolean;
-}

package/bin/impl/utils/pm/pm-utils.d.ts

@@ -1,12 +0,0 @@
-import type { OperationOptions, PackageManager } from "./pm-types";
-export declare function executeCommand(command: string, args: string[], options?: Pick<OperationOptions, "cwd" | "silent">): Promise<void>;
-type NonPartial<T> = {
-    [P in keyof T]-?: T[P];
-};
-export declare const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
-export declare function resolveOperationOptions(options?: OperationOptions): Promise<NonPartial<Pick<OperationOptions, "cwd" | "silent" | "dev" | "global">> & Pick<OperationOptions, "workspace" | "filter" | "asCatalog" | "catalogName"> & {
-    packageManager: PackageManager;
-}>;
-export declare function getWorkspaceArgs(options: Awaited<ReturnType<typeof resolveOperationOptions>>): string[];
-export declare function doesDependencyExist(name: string, options: Pick<Awaited<ReturnType<typeof resolveOperationOptions>>, "cwd" | "workspace">): boolean;
-export {};

package/bin/impl/utils/pm/pm-utils.js

@@ -1,115 +0,0 @@
-import { createRequire } from "node:module";
-import { resolve } from "@reliverse/pathkit";
-import { x } from "../exec/exec-mod.js";
-import { detectPackageManager, packageManagers } from "./pm-detect.js";
-function cached(fn) {
-  let v;
-  return () => {
-    if (v === void 0) {
-      v = fn().then((r) => {
-        v = r;
-        return v;
-      });
-    }
-    return v;
-  };
-}
-const hasCorepack = cached(async () => {
-  if (globalThis.process?.versions?.webcontainer) {
-    return false;
-  }
-  try {
-    const { exitCode } = await x("corepack", ["--version"]);
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-});
-export async function executeCommand(command, args, options = {}) {
-  console.log("DEBUG: executeCommand called with:", {
-    command,
-    args,
-    options,
-    commandType: typeof command,
-    argsType: typeof args,
-    isArgsArray: Array.isArray(args)
-  });
-  if (!Array.isArray(args)) {
-    throw new Error(`executeCommand: args must be an array, got ${typeof args}: ${args}`);
-  }
-  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
-  console.log("DEBUG: executeCommand xArgs:", {
-    xArgs,
-    command: xArgs[0],
-    args: xArgs[1],
-    commandType: typeof xArgs[0],
-    argsType: typeof xArgs[1],
-    isArgsArray: Array.isArray(xArgs[1])
-  });
-  const { exitCode, stdout, stderr } = await x(xArgs[0], xArgs[1], {
-    nodeOptions: {
-      cwd: resolve(options.cwd || process.cwd()),
-      stdio: options.silent ? "pipe" : "inherit"
-    }
-  });
-  if (exitCode !== 0) {
-    throw new Error(
-      `\`${xArgs.flat().join(" ")}\` failed.${options.silent ? ["", stdout, stderr].join("\n") : ""}`
-    );
-  }
-}
-export const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
-export async function resolveOperationOptions(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const packageManager = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
-  if (!packageManager) {
-    throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
-  }
-  return {
-    cwd,
-    silent: options.silent ?? false,
-    packageManager,
-    dev: options.dev ?? false,
-    workspace: options.workspace,
-    filter: options.filter,
-    asCatalog: options.asCatalog,
-    catalogName: options.catalogName,
-    global: options.global ?? false
-  };
-}
-export function getWorkspaceArgs(options) {
-  const args = [];
-  if (options.filter && options.filter.length > 0) {
-    for (const filter of options.filter) {
-      args.push("--filter", filter);
-    }
-    return args;
-  }
-  if (!options.workspace) {
-    return [];
-  }
-  const workspacePkg = typeof options.workspace === "string" && options.workspace !== "" ? options.workspace : void 0;
-  if (options.packageManager.name === "pnpm") {
-    return workspacePkg ? ["--filter", workspacePkg] : ["--workspace-root"];
-  }
-  if (options.packageManager.name === "npm") {
-    return workspacePkg ? ["-w", workspacePkg] : ["--workspaces"];
-  }
-  if (options.packageManager.name === "yarn") {
-    if (!options.packageManager.majorVersion || options.packageManager.majorVersion === "1") {
-      return workspacePkg ? ["--cwd", workspacePkg] : ["-W"];
-    } else {
-      return workspacePkg ? ["workspace", workspacePkg] : [];
-    }
-  }
-  return [];
-}
-export function doesDependencyExist(name, options) {
-  const require = createRequire(options.cwd.endsWith("/") ? options.cwd : options.cwd + "/");
-  try {
-    const resolvedPath = require.resolve(name);
-    return resolvedPath.startsWith(options.cwd);
-  } catch {
-    return false;
-  }
-}