@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/utils/init/init-tmpl.js

@@ -1,68 +0,0 @@
-export const gitignoreTemplate = `*.log
-.env
-.DS_Store
-.eslintcache
-node_modules
-dist-jsr
-dist-libs
-dist-npm
-`;
-export const readmeTemplate = `# \u{1F680} Project Name
-Welcome! This project was bootstrapped with [@reliverse/reinit](https://www.npmjs.com/package/@reliverse/reinit).  
-It's already got the basics \u2014 now it's your turn to make it awesome \u2728
-## \u{1F527} Tech Stack
-- \u2699\uFE0F Framework: _<Add your framework here>_
-- \u{1F6E0}\uFE0F Tools: _<Add your tooling, CLIs, etc>_
-- \u{1F9EA} Tests: _<Vitest, Jest, or something else?>_
-- \u{1F9E0} Linting: _ESLint, Biome, etc_
-- \u{1F310} Deployment: _<Vercel, Netlify, Railway?>_
-## \u{1F680} Getting Started
-Clone the repo and install dependencies:
-'''bash
-bun install
-bun dev
-'''
-Or if you're using another package manager:
-'''bash
-npm install && npm run dev
-# or
-pnpm i && pnpm dev
-'''
-## \u{1F5C2}\uFE0F Project Structure
-'''bash
-src/
-\u251C\u2500\u2500 components/
-\u251C\u2500\u2500 pages/
-\u251C\u2500\u2500 lib/
-\u2514\u2500\u2500 styles/
-'''
-Feel free to tweak the structure to your liking.
-## \u{1F9E9} Customize it
-This project is just a starting point. You can add:
-- \u{1F9D9}\u200D\u2642\uFE0F Your own components and UI
-- \u{1F4E6} APIs, auth, i18n, analytics, etc.
-- \u{1F916} Whatever you need
-## \u{1FAF6} Credits
-Made with \u2764\uFE0F using [@reliverse/reinit](https://reliverse.org)  
-Need help? [Join the Discord](https://discord.gg/Pb8uKbwpsJ)
-## \u{1F4C4} License
-MIT \xA9 YourNameHere
-`;
-export const licenseTemplate = `# MIT License
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-`;

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

@@ -1,41 +0,0 @@
-import type { DEST_FILE_EXISTS_BEHAVIOURS, FILE_TYPES, INIT_BEHAVIOURS } from "./init-const";
-export type FileType = (typeof FILE_TYPES)[number]["type"];
-export type InitBehaviour = (typeof INIT_BEHAVIOURS)[number];
-export type DestFileExistsBehaviour = (typeof DEST_FILE_EXISTS_BEHAVIOURS)[number];
-/** Library-level interface for hooking into the file init process. */
-export interface ReinitUserConfig {
-    /** The default approach for copying vs. creating. */
-    defaultInitBehaviour?: InitBehaviour;
-    /** Default approach if a file already exists. */
-    defaultDestFileExistsBehaviour?: DestFileExistsBehaviour;
-    /** Whether `initFiles` should run in parallel by default. */
-    parallelByDefault?: boolean;
-    /** Concurrency limit for parallel tasks. If omitted, 4 is used. */
-    parallelConcurrency?: number;
-    /** Called before each file operation. */
-    onFileStart?: (req: InitFileRequest) => void;
-    /** Called after each file operation. */
-    onFileComplete?: (res: InitFileResult) => void;
-}
-/** Data describing a single request to initFile. */
-export interface InitFileRequest {
-    fileType: FileType;
-    destDir: string;
-    initBehaviour?: InitBehaviour;
-    destFileExistsBehaviour?: DestFileExistsBehaviour;
-    options?: InitFileOptions;
-}
-/** Extended per-file options. */
-export interface InitFileOptions {
-    destFileName?: string;
-    srcCopyMode?: string;
-    contentCreateMode?: string;
-    fallbackSource?: string;
-}
-/** The result of a single initFile operation. */
-export interface InitFileResult {
-    requested: InitFileRequest;
-    finalPath?: string;
-    status: "created" | "copied" | "skipped" | "error";
-    error?: any;
-}

package/bin/impl/utils/instanceGithub.d.ts

@@ -1,28 +0,0 @@
-import { Octokit } from "@octokit/rest";
-import type { ReliverseMemory } from "./schemaMemory";
-export declare const OctokitWithRest: typeof Octokit;
-export declare const octokitUserAgent: string;
-export type InstanceGithub = InstanceType<typeof OctokitWithRest>;
-/**
- * Ensures a valid GitHub token is available in rse's memory.
- *
- * If a token is already stored in memory, this function validates it by fetching the
- * authenticated user's information. If the token is missing or invalid, the user is prompted
- * to input one. The new token is then saved persistently.
- *
- * @param memory - The rse memory object.
- * @param maskInput - A flag or the string "prompt" that determines if input should be masked.
- * @returns The valid GitHub token.
- */
-export declare function ensureGithubToken(memory: ReliverseMemory, maskInput: "prompt" | boolean): Promise<string>;
-/**
- * Initializes a GitHub SDK instance and returns the GitHub token along with the Octokit instance.
- *
- * This function is analogous to the Vercel SDK init function; it ensures that a valid GitHub token is
- * available (prompting for one if necessary), initializes Octokit with the token, and returns both.
- *
- * @param memory - The rse memory object.
- * @param maskInput - A flag or "prompt" to determine if the token input should be masked.
- * @returns A tuple containing the GitHub token and works as the wrapper for the Octokit instance.
- */
-export declare function initGithubSDK(memory: ReliverseMemory, frontendUsername: string, maskInput: "prompt" | boolean): Promise<[string, InstanceGithub, string]>;

package/bin/impl/utils/instanceGithub.js

@@ -1,50 +0,0 @@
-import { restEndpointMethods } from "@octokit/plugin-rest-endpoint-methods";
-import { Octokit } from "@octokit/rest";
-import { relinka } from "@reliverse/relinka";
-import { inputPrompt } from "@reliverse/rempts";
-import { cliVersion } from "../config/constants.js";
-import { askUsernameGithub } from "./prompts/askUsernameGithub.js";
-import { updateReliverseMemory } from "./reliverseMemory.js";
-export const OctokitWithRest = Octokit.plugin(restEndpointMethods);
-export const octokitUserAgent = `rse/${cliVersion}`;
-function initOctokitSDK(githubKey) {
-  return new OctokitWithRest({
-    auth: githubKey.trim(),
-    userAgent: octokitUserAgent,
-    throttle: {
-      onRateLimit: (_retryAfter, options, octokit) => {
-        octokit.log.warn(`Request quota exhausted for ${options.method} ${options.url}`);
-        return options.request.retryCount === 0;
-      },
-      onSecondaryRateLimit: (_retryAfter, options, octokit) => {
-        octokit.log.warn(`Secondary rate limit encountered for ${options.method} ${options.url}`);
-        return options.request.retryCount === 0;
-      }
-    }
-  });
-}
-export async function ensureGithubToken(memory, maskInput) {
-  if (memory.githubKey) {
-    try {
-      const octokit = initOctokitSDK(memory.githubKey);
-      await octokit.rest.users.getAuthenticated();
-      return memory.githubKey.trim();
-    } catch (error) {
-      relinka("warn", "Existing GitHub token is invalid. Please provide a new one.");
-      relinka("verbose", error instanceof Error ? error.message : String(error));
-    }
-  }
-  const token = await inputPrompt({
-    title: "Please enter your GitHub personal access token.\n(It will be securely stored on your machine):",
-    content: "Create one at https://github.com/settings/tokens/new\nEnsure you select the `repo` scope, then click `Generate token`.",
-    mode: maskInput ? "password" : "plain"
-  });
-  await updateReliverseMemory({ githubKey: token });
-  return token;
-}
-export async function initGithubSDK(memory, frontendUsername, maskInput) {
-  const githubUsername = await askUsernameGithub(memory, frontendUsername);
-  const githubToken = await ensureGithubToken(memory, maskInput);
-  const githubInstance = initOctokitSDK(githubToken);
-  return [githubToken, githubInstance, githubUsername];
-}

package/bin/impl/utils/instanceVercel.d.ts

@@ -1,16 +0,0 @@
-import { VercelCore } from "@vercel/sdk/core";
-import type { ReliverseMemory } from "./schemaMemory.js";
-export type InstanceVercel = VercelCore;
-/**
- * Prompts the user for a Vercel token if none is stored
- */
-export declare function askVercelToken(maskInput: boolean, memory: ReliverseMemory): Promise<string | undefined>;
-/**
- * Creates a new Vercel SDK instance by obtaining the token either from memory
- * or by prompting the user. The token is then used to initialize VercelCore.
- *
- * It's recommended to call it once and pass the instance through the user flow.
- *
- * This `@vercel/sdk` init returns `[token, vercel]`.
- */
-export declare function initVercelSDK(memory: ReliverseMemory, maskInput: boolean): Promise<[string, VercelCore] | undefined>;

package/bin/impl/utils/instanceVercel.js

@@ -1,39 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { inputPrompt } from "@reliverse/rempts";
-import { VercelCore } from "@vercel/sdk/core";
-import { saveVercelToken } from "../init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-utils.js";
-export async function askVercelToken(maskInput, memory) {
-  if (!memory?.vercelKey) {
-    const token = await inputPrompt({
-      title: "Please enter your Vercel personal access token.\n(It will be securely stored on your machine):",
-      content: "Create one at https://vercel.com/account/settings/tokens",
-      mode: maskInput ? "password" : "plain",
-      validate: (value) => {
-        if (!value?.trim()) return "Token is required";
-        return true;
-      }
-    });
-    if (!token) {
-      relinka("error", "No token provided");
-      return;
-    }
-    return token;
-  }
-  return memory.vercelKey;
-}
-export async function initVercelSDK(memory, maskInput) {
-  let vercelToken = memory?.vercelKey;
-  if (!vercelToken) {
-    vercelToken = await askVercelToken(maskInput, memory);
-    if (!vercelToken) {
-      relinka("error", "No token provided");
-      return;
-    }
-  }
-  const vercelInstance = new VercelCore({ bearerToken: vercelToken });
-  if (!memory.vercelKey) {
-    await saveVercelToken(vercelToken, memory, vercelInstance);
-    memory.vercelKey = vercelToken;
-  }
-  return [vercelToken, vercelInstance];
-}

package/bin/impl/utils/microHelpers.d.ts

@@ -1,11 +0,0 @@
-/**
- * Helper function to compute maximum items based on terminal height.
- * @returns Number of maximum items allowed.
- */
-export declare function getMaxHeightSize(): number;
-/**
- * Sleeps for the specified number of milliseconds.
- * @param ms - Milliseconds to sleep.
- * @returns A promise that resolves after the given time.
- */
-export declare function sleep(ms: number): Promise<void>;

package/bin/impl/utils/microHelpers.js

@@ -1,8 +0,0 @@
-import { getTerminalHeight } from "@reliverse/rempts";
-export function getMaxHeightSize() {
-  const hSize = getTerminalHeight();
-  return hSize < 30 ? 10 : hSize;
-}
-export function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/bin/impl/utils/mrseHelpers.d.ts

@@ -1,6 +0,0 @@
-export declare function hasConfigFiles(projectPath: string): Promise<boolean>;
-/**
- * Checks if the given project path is a Mrse project
- * @param projectPath The path to the project to check
- */
-export declare function isMrseProject(projectPath: string): Promise<boolean>;

package/bin/impl/utils/mrseHelpers.js

@@ -1,21 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-export async function hasConfigFiles(projectPath) {
-  try {
-    const files = await fs.readdir(projectPath);
-    return files.some(
-      (file) => (file.endsWith(".jsonc") || file.endsWith(".ts")) && !file.includes("mrse.")
-    );
-  } catch (_err) {
-    return false;
-  }
-}
-export async function isMrseProject(projectPath) {
-  const configPath = path.join(projectPath, ".config");
-  const mrseFolderPath = path.join(projectPath, "mrse");
-  const hasMrseConfig = await Promise.all([
-    fs.pathExists(path.join(configPath, "mreliverse.ts")),
-    fs.pathExists(path.join(configPath, "mreliverse.jsonc"))
-  ]).then(([hasTs, hasJsonc]) => hasTs || hasJsonc);
-  return hasMrseConfig && await fs.pathExists(mrseFolderPath) && await hasConfigFiles(mrseFolderPath);
-}

package/bin/impl/utils/pkgJsonHelpers.d.ts

@@ -1,7 +0,0 @@
-/**
- * Checks if a specific script exists in package.json
- * @param projectPath - Path to the project directory containing package.json
- * @param scriptName - Name of the script to check for
- * @returns Promise resolving to true if the script exists, false otherwise
- */
-export declare function checkScriptExists(projectPath: string, scriptName: string): Promise<boolean>;

package/bin/impl/utils/pkgJsonHelpers.js

@@ -1,15 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON } from "pkg-types";
-export async function checkScriptExists(projectPath, scriptName) {
-  try {
-    const packageJson = await readPackageJSON(projectPath);
-    return !!packageJson?.scripts?.[scriptName];
-  } catch (error) {
-    relinka(
-      "error",
-      `Error checking for script ${scriptName}:`,
-      error instanceof Error ? error.message : String(error)
-    );
-    return false;
-  }
-}

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

@@ -1,87 +0,0 @@
-import type { OperationOptions } from "./pm-types";
-/**
- * Installs project dependencies.
- *
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.packageManager - The package manager info to use (auto-detected).
- * @param options.frozenLockFile - Whether to install dependencies with frozen lock file.
- * @param options.filter - Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c').
- */
-export declare function installDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager" | "filter"> & {
-    frozenLockFile?: boolean;
-}): Promise<void>;
-/**
- * Adds dependency to the project.
- *
- * @param name - Name of the dependency to add.
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.packageManager - The package manager info to use (auto-detected).
- * @param options.dev - Whether to add the dependency as dev dependency.
- * @param options.workspace - The name of the workspace to use.
- * @param options.global - Whether to run the command in global mode.
- */
-export declare function addDependency(name: string | string[], options?: OperationOptions): Promise<void>;
-/**
- * Adds dev dependency to the project.
- *
- * @param name - Name of the dev dependency to add.
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.packageManager - The package manager info to use (auto-detected).
- * @param options.workspace - The name of the workspace to use.
- * @param options.global - Whether to run the command in global mode.
- *
- */
-export declare function addDevDependency(name: string | string[], options?: Omit<OperationOptions, "dev">): Promise<void>;
-/**
- * Removes dependency from the project.
- *
- * @param name - Name of the dependency to remove.
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.packageManager - The package manager info to use (auto-detected).
- * @param options.dev - Whether to remove dev dependency.
- * @param options.workspace - The name of the workspace to use.
- * @param options.global - Whether to run the command in global mode.
- * @param options.filter - Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c').
- */
-export declare function removeDependency(name: string | string[], options?: OperationOptions): Promise<void>;
-/**
- * Ensures dependency is installed.
- *
- * @param name - Name of the dependency.
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.dev - Whether to install as dev dependency (if not already installed).
- * @param options.workspace - The name of the workspace to install dependency in (if not already installed).
- */
-export declare function ensureDependencyInstalled(name: string, options?: Pick<OperationOptions, "cwd" | "dev" | "workspace">): Promise<true | undefined>;
-/**
- * Dedupe dependencies in the project.
- *
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.packageManager - The package manager info to use (auto-detected).
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.recreateLockfile - Whether to recreate the lockfile instead of deduping.
- */
-export declare function dedupeDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager"> & {
-    recreateLockfile?: boolean;
-}): Promise<void>;
-export declare function updateDependencies(latest?: boolean, options?: OperationOptions): Promise<void>;
-/**
- * Runs a script defined in the package.json file.
- *
- * @param name - Name of the script to run.
- * @param options - Options to pass to the API call.
- * @param options.cwd - The directory to run the command in.
- * @param options.silent - Whether to run the command in silent mode.
- * @param options.packageManager - The package manager info to use (auto-detected).
- */
-export declare function runScript(name: string, options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager">): Promise<void>;

package/bin/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 {
-  doesDependencyExist,
-  executeCommand,
-  getWorkspaceArgs,
-  resolveOperationOptions
-} 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/impl/utils/pm/pm-catalog.d.ts

@@ -1,36 +0,0 @@
-import type { PackageManager } from "./pm-types";
-/**
- * Interface for catalog structure
- */
-export interface CatalogStructure {
-    catalog?: Record<string, string>;
-    catalogs?: Record<string, Record<string, string>>;
-}
-/**
- * Get catalog structure from package.json
- */
-export declare function getCatalogStructure(cwd?: string): Promise<CatalogStructure>;
-/**
- * Add dependencies to catalog
- */
-export declare function addToCatalog(dependencies: string[], catalogType: "catalog" | "catalogs", catalogName?: string, cwd?: string): Promise<void>;
-/**
- * Check if catalog is supported by package manager
- */
-export declare function isCatalogSupported(packageManager: PackageManager): boolean;
-/**
- * Get catalog reference format for a dependency
- */
-export declare function getCatalogReference(dependency: string, catalogType: "catalog" | "catalogs", catalogName?: string): string;
-/**
- * List all catalogs and their dependencies
- */
-export declare function listCatalogs(cwd?: string): Promise<void>;
-/**
- * Update catalog dependencies to latest versions
- */
-export declare function updateCatalogs(cwd?: string): Promise<void>;
-/**
- * Remove dependencies from catalog
- */
-export declare function removeFromCatalog(dependencies: string[], catalogType: "catalog" | "catalogs", catalogName?: string, cwd?: string): Promise<void>;