@reliverse/dler 1.7.91 → 1.7.93

package/bin/libs/sdk/sdk-impl/utils/file-type.js

@@ -1,78 +0,0 @@
-import path from "@reliverse/pathkit";
-import {
-  fileTypeFromFile,
-  fileTypeFromBuffer,
-  fileTypeFromStream
-} from "file-type";
-import { BINARY_SET } from "./b-exts.js";
-export async function detectFileType(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result) return result;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return {
-        ext,
-        mime: `application/${ext}`
-        // Generic MIME type as fallback
-      };
-    }
-    return void 0;
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return {
-        ext,
-        mime: `application/${ext}`
-        // Generic MIME type as fallback
-      };
-    }
-    return void 0;
-  }
-}
-export async function detectBufferType(buffer) {
-  try {
-    const result = await fileTypeFromBuffer(buffer);
-    if (result) return result;
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-export async function detectStreamType(stream) {
-  try {
-    const result = await fileTypeFromStream(stream);
-    if (result) return result;
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-export async function isBinary(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result) return true;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    return BINARY_SET.has(ext);
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    return BINARY_SET.has(ext);
-  }
-}
-export async function getMimeType(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result?.mime) return result.mime;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return `application/${ext}`;
-    }
-    return void 0;
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return `application/${ext}`;
-    }
-    return void 0;
-  }
-}

package/bin/libs/sdk/sdk-impl/utils/finalize.d.ts

@@ -1,10 +0,0 @@
-import type { LibConfig } from "../config/types.js";
-import type { PerfTimer } from "../sdk-types.js";
-/**
- * Finalizes the build process and reports completion.
- */
-export declare function finalizeBuild(timer: PerfTimer, commonPubPause: boolean, usedMode: "build" | "pub"): Promise<void>;
-/**
- * Finalizes the publish process, cleans up, and reports completion.
- */
-export declare function finalizePub(timer: PerfTimer, libsList: Record<string, LibConfig>, distNpmDirName: string, distJsrDirName: string, libsDirDist: string): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/finalize.js

@@ -1,34 +0,0 @@
-import { setBumpDisabledValueTo } from "@reliverse/bleump";
-import { relinka } from "@reliverse/relinka";
-import prettyMilliseconds from "pretty-ms";
-import { removeDistFolders } from "./utils-clean.js";
-import { getElapsedPerfTime } from "./utils-perf.js";
-function providePublishGuidance(usedMode, commonPubPause) {
-  if (commonPubPause) {
-    relinka("info", "\u{1F4DD} Publishing is paused in your config (commonPubPause=true)");
-    relinka(
-      "info",
-      usedMode === "pub" ? "\u{1F4A1} To enable publishing: set commonPubPause=false in your config" : "\u{1F4A1} To publish: set commonPubPause=false, then run 'dler pub'"
-    );
-  } else {
-    relinka("info", "\u{1F4A1} To publish: run 'dler pub'");
-  }
-}
-export async function finalizeBuild(timer, commonPubPause, usedMode) {
-  const elapsedTime = getElapsedPerfTime(timer);
-  const formattedPerfTime = prettyMilliseconds(elapsedTime, { verbose: true });
-  console.log("\n" + "=".repeat(60));
-  relinka("success", `\u{1F389} Build completed successfully in ${formattedPerfTime}`);
-  providePublishGuidance(usedMode, commonPubPause);
-}
-export async function finalizePub(timer, libsList, distNpmDirName, distJsrDirName, libsDirDist) {
-  const elapsedTime = getElapsedPerfTime(timer);
-  const formattedPerfTime = prettyMilliseconds(elapsedTime, { verbose: true });
-  await removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList);
-  try {
-    await setBumpDisabledValueTo(false);
-  } catch {
-    throw new Error("[.config/dler.ts] Failed to set bumpDisable to false");
-  }
-  relinka("success", `\u{1F389} Build and publish completed successfully in ${formattedPerfTime}`);
-}

package/bin/libs/sdk/sdk-impl/utils/fs-rename.js

@@ -1,108 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-async function fileExists(path2) {
-  try {
-    await fs.access(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export async function safeRename(source, destination) {
-  if (await fileExists(destination)) {
-    throw new Error(`Destination file already exists: ${destination}`);
-  }
-  await fs.rename(source, destination);
-}
-function isCommonJSFile(content) {
-  return content.includes("module.exports") || content.includes("require(");
-}
-async function getAllFilesAsync(dir, baseDir = dir, recursive = true) {
-  let fileList = [];
-  const entries = await fs.readdir(dir, {
-    encoding: "utf8",
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (recursive) {
-        const subFiles = await getAllFilesAsync(fullPath, baseDir, recursive);
-        fileList = fileList.concat(subFiles);
-      }
-    } else if (entry.isFile()) {
-      fileList.push(fullPath.slice(baseDir.length + 1));
-    }
-  }
-  return fileList;
-}
-export async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPrepareMyCLI = false) {
-  relinka("verbose", "Starting CLI file preparation...");
-  const configPath = ".config/dler.ts";
-  let srcDir = "src";
-  if (fs.existsSync(configPath)) {
-    const configContent = fs.readFileSync(configPath, "utf8");
-    const configMatch = configContent.match(/coreEntrySrcDir:\s*["']([^"']+)["']/);
-    srcDir = configMatch?.[1] ?? srcDir;
-  }
-  if (!fs.existsSync(srcDir)) {
-    throw new Error(`Source directory not found: ${srcDir}`);
-  }
-  const files = await getAllFilesAsync(srcDir, srcDir, recursive);
-  relinka("verbose", `Found ${files.length} files to process.`);
-  let renamedCount = 0;
-  for (const file of files) {
-    const fullPath = path.join(srcDir, file);
-    if (!await fileExists(fullPath)) continue;
-    const ext = path.extname(file);
-    const fileName = path.basename(file);
-    const baseName = path.basename(file, ext);
-    const dir = path.dirname(fullPath);
-    if (revert) {
-      if (file.endsWith(".json.json")) {
-        const originalName = path.join(dir, fileName.replace(".json.json", ".json"));
-        relinka("verbose", `Reverting ${fullPath} to ${originalName}`);
-        await safeRename(fullPath, originalName);
-        renamedCount++;
-      } else if (file.endsWith(".d.ts.txt") && useDtsTxtForPrepareMyCLI) {
-        const originalName = path.join(dir, fileName.replace(".d.ts.txt", ".d.ts"));
-        relinka("verbose", `Reverting ${fullPath} to ${originalName}`);
-        await safeRename(fullPath, originalName);
-        renamedCount++;
-      } else if (file.endsWith(".cjs")) {
-        const originalName = path.join(dir, `${baseName}.js`);
-        relinka("verbose", `Reverting ${fullPath} to ${originalName}`);
-        await safeRename(fullPath, originalName);
-        renamedCount++;
-      }
-    } else {
-      if (fileName === "tsconfig.json" && !fileName.endsWith(".json.json")) {
-        const newName = path.join(dir, "tsconfig.json.json");
-        relinka("verbose", `Renaming ${fullPath} to ${newName}`);
-        await safeRename(fullPath, newName);
-        renamedCount++;
-      } else if (fileName === "package.json" && !fileName.endsWith(".json.json")) {
-        const newName = path.join(dir, "package.json.json");
-        relinka("verbose", `Renaming ${fullPath} to ${newName}`);
-        await safeRename(fullPath, newName);
-        renamedCount++;
-      } else if (fileName.endsWith(".d.ts") && !fileName.endsWith(".d.ts.txt") && useDtsTxtForPrepareMyCLI) {
-        const baseWithoutD = baseName.slice(0, -2);
-        const newName = path.join(dir, `${baseWithoutD}.d.ts.txt`);
-        relinka("verbose", `Renaming ${fullPath} to ${newName}`);
-        await safeRename(fullPath, newName);
-        renamedCount++;
-      } else if (fileName.endsWith(".js") && !fileName.endsWith(".cjs")) {
-        const content = fs.readFileSync(fullPath, "utf8");
-        if (isCommonJSFile(content)) {
-          const newName = path.join(dir, `${baseName}.cjs`);
-          relinka("verbose", `Renaming ${fullPath} to ${newName}`);
-          await safeRename(fullPath, newName);
-          renamedCount++;
-        }
-      }
-    }
-  }
-  relinka("verbose", `CLI file preparation completed. Renamed ${renamedCount} files.`);
-}

package/bin/libs/sdk/sdk-impl/utils/init/init-const.d.ts

@@ -1,34 +0,0 @@
-/**
- * Known file types with possible variations.
- */
-export declare const FILE_TYPES: readonly [{
-    readonly type: "cfg:eslint";
-    readonly variations: readonly ["eslint.config.js"];
-}, {
-    readonly type: "cfg:knip";
-    readonly variations: readonly ["knip.json"];
-}, {
-    readonly type: "cfg:reliverse";
-    readonly variations: readonly [".config/rse.jsonc", ".config/rse.ts"];
-}, {
-    readonly type: "cfg:package.json";
-    readonly variations: readonly ["package.json"];
-}, {
-    readonly type: "cfg:tsconfig.json";
-    readonly variations: readonly ["tsconfig.json"];
-}, {
-    readonly type: "git:gitattributes";
-    readonly variations: readonly [".gitattributes"];
-}, {
-    readonly type: "git:gitignore";
-    readonly variations: readonly [".gitignore"];
-}, {
-    readonly type: "md:LICENSE";
-    readonly variations: readonly ["LICENSE.md", "LICENSE"];
-}, {
-    readonly type: "md:README";
-    readonly variations: readonly ["README.md", "README"];
-}];
-export declare const INIT_BEHAVIOURS: readonly ["create", "copy", "create-if-copy-failed"];
-export declare const DEST_FILE_EXISTS_BEHAVIOURS: readonly ["rewrite", "skip", "attach-index", "prompt"];
-export declare const CONTENT_CREATE_MODES: string[];

package/bin/libs/sdk/sdk-impl/utils/init/init-const.js

@@ -1,17 +0,0 @@
-export const FILE_TYPES = [
-  { type: "cfg:eslint", variations: ["eslint.config.js"] },
-  { type: "cfg:knip", variations: ["knip.json"] },
-  {
-    type: "cfg:reliverse",
-    variations: [".config/rse.jsonc", ".config/rse.ts"]
-  },
-  { type: "cfg:package.json", variations: ["package.json"] },
-  { type: "cfg:tsconfig.json", variations: ["tsconfig.json"] },
-  { type: "git:gitattributes", variations: [".gitattributes"] },
-  { type: "git:gitignore", variations: [".gitignore"] },
-  { type: "md:LICENSE", variations: ["LICENSE.md", "LICENSE"] },
-  { type: "md:README", variations: ["README.md", "README"] }
-];
-export const INIT_BEHAVIOURS = ["create", "copy", "create-if-copy-failed"];
-export const DEST_FILE_EXISTS_BEHAVIOURS = ["rewrite", "skip", "attach-index", "prompt"];
-export const CONTENT_CREATE_MODES = ["license-basic", "simple-readme"];

package/bin/libs/sdk/sdk-impl/utils/pm/pm-api.js

@@ -1,170 +0,0 @@
-import { resolve } from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { readPackageJSON } from "pkg-types";
-import {
-  executeCommand,
-  resolveOperationOptions,
-  getWorkspaceArgs,
-  doesDependencyExist
-} from "./pm-utils.js";
-export async function installDependencies(options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const pmToFrozenLockfileInstallCommand = {
-    npm: ["ci"],
-    yarn: ["install", "--immutable"],
-    bun: ["install", "--frozen-lockfile"],
-    pnpm: ["install", "--frozen-lockfile"],
-    deno: ["install", "--frozen"]
-  };
-  const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
-  const workspaceArgs = getWorkspaceArgs(resolvedOptions);
-  const finalArgs = [...commandArgs, ...workspaceArgs];
-  await executeCommand(resolvedOptions.packageManager.command, finalArgs, {
-    cwd: resolvedOptions.cwd,
-    silent: resolvedOptions.silent
-  });
-}
-export async function addDependency(name, options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const names = Array.isArray(name) ? name : [name];
-  if (resolvedOptions.packageManager.name === "deno") {
-    for (let i = 0; i < names.length; i++) {
-      if (!/^(npm|jsr|file):.+$/.test(names[i] || "")) {
-        names[i] = `npm:${names[i]}`;
-      }
-    }
-  }
-  if (names.length === 0) {
-    return;
-  }
-  const args = (resolvedOptions.packageManager.name === "yarn" ? [
-    ...getWorkspaceArgs(resolvedOptions),
-    // Global is not supported in berry: yarnpkg/berry#821
-    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
-    "add",
-    resolvedOptions.dev ? "-D" : "",
-    ...names
-  ] : [
-    resolvedOptions.packageManager.name === "npm" ? "install" : "add",
-    ...getWorkspaceArgs(resolvedOptions),
-    resolvedOptions.dev ? "-D" : "",
-    resolvedOptions.global ? "-g" : "",
-    ...names
-  ]).filter(Boolean);
-  await executeCommand(resolvedOptions.packageManager.command, args, {
-    cwd: resolvedOptions.cwd,
-    silent: resolvedOptions.silent
-  });
-  if (options.installPeerDependencies) {
-    const existingPkg = await readPackageJSON(resolvedOptions.cwd);
-    const peerDeps = [];
-    const peerDevDeps = [];
-    for (const _name of names) {
-      const pkgName = _name.match(/^(.[^@]+)/)?.[0];
-      const pkg = await readPackageJSON(pkgName, {
-        url: resolvedOptions.cwd
-      }).catch(() => ({}));
-      if (!pkg.peerDependencies || pkg.name !== pkgName) {
-        continue;
-      }
-      for (const [peerDependency, version] of Object.entries(pkg.peerDependencies)) {
-        if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) {
-          continue;
-        }
-        if (existingPkg.dependencies?.[peerDependency] || existingPkg.devDependencies?.[peerDependency]) {
-          continue;
-        }
-        const isDev = pkg.peerDependenciesMeta?.[peerDependency]?.dev;
-        (isDev ? peerDevDeps : peerDeps).push(`${peerDependency}@${version}`);
-      }
-    }
-    if (peerDeps.length > 0) {
-      await addDependency(peerDeps, { ...resolvedOptions });
-    }
-    if (peerDevDeps.length > 0) {
-      await addDevDependency(peerDevDeps, { ...resolvedOptions });
-    }
-  }
-}
-export async function addDevDependency(name, options = {}) {
-  await addDependency(name, { ...options, dev: true });
-}
-export async function removeDependency(name, options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const names = Array.isArray(name) ? name : [name];
-  if (names.length === 0) {
-    return;
-  }
-  const args = (resolvedOptions.packageManager.name === "yarn" ? [
-    // Global is not supported in berry: yarnpkg/berry#821
-    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
-    ...getWorkspaceArgs(resolvedOptions),
-    "remove",
-    resolvedOptions.dev ? "-D" : "",
-    resolvedOptions.global ? "-g" : "",
-    ...names
-  ] : [
-    resolvedOptions.packageManager.name === "npm" ? "uninstall" : "remove",
-    ...getWorkspaceArgs(resolvedOptions),
-    resolvedOptions.dev ? "-D" : "",
-    resolvedOptions.global ? "-g" : "",
-    ...names
-  ]).filter(Boolean);
-  await executeCommand(resolvedOptions.packageManager.command, args, {
-    cwd: resolvedOptions.cwd,
-    silent: resolvedOptions.silent
-  });
-}
-export async function ensureDependencyInstalled(name, options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const dependencyExists = doesDependencyExist(name, resolvedOptions);
-  if (dependencyExists) {
-    return true;
-  }
-  await addDependency(name, resolvedOptions);
-}
-export async function dedupeDependencies(options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const isSupported = !["bun", "deno"].includes(resolvedOptions.packageManager.name);
-  const recreateLockfile = options.recreateLockfile ?? !isSupported;
-  if (recreateLockfile) {
-    const lockfiles = Array.isArray(resolvedOptions.packageManager.lockFile) ? resolvedOptions.packageManager.lockFile : [resolvedOptions.packageManager.lockFile];
-    for (const lockfile of lockfiles) {
-      if (lockfile) fs.rmSync(resolve(resolvedOptions.cwd, lockfile), { force: true });
-    }
-    await installDependencies(resolvedOptions);
-    return;
-  }
-  if (isSupported) {
-    const isyarnv1 = resolvedOptions.packageManager.name === "yarn" && resolvedOptions.packageManager.majorVersion === "1";
-    await executeCommand(
-      resolvedOptions.packageManager.command,
-      [isyarnv1 ? "install" : "dedupe"],
-      {
-        cwd: resolvedOptions.cwd,
-        silent: resolvedOptions.silent
-      }
-    );
-    return;
-  }
-  throw new Error(`Deduplication is not supported for ${resolvedOptions.packageManager.name}`);
-}
-export async function updateDependencies(latest = true, options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  await executeCommand(
-    resolvedOptions.packageManager.command,
-    latest ? ["update", "--latest"] : ["update"],
-    {
-      cwd: resolvedOptions.cwd,
-      silent: resolvedOptions.silent
-    }
-  );
-}
-export async function runScript(name, options = {}) {
-  const resolvedOptions = await resolveOperationOptions(options);
-  const args = [resolvedOptions.packageManager.name === "deno" ? "task" : "run", name];
-  await executeCommand(resolvedOptions.packageManager.command, args, {
-    cwd: resolvedOptions.cwd,
-    silent: resolvedOptions.silent
-  });
-}

package/bin/libs/sdk/sdk-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) {
-    delete 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/libs/sdk/sdk-impl/utils/pm/pm-utils.js

@@ -1,115 +0,0 @@
-import { resolve } from "@reliverse/pathkit";
-import { createRequire } from "node:module";
-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;
-  }
-}