@reliverse/dler 1.7.60 → 1.7.61

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

@@ -0,0 +1,173 @@
+import { resolve } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { runCmd } from "@reliverse/rempts";
+import { readPackageJSON } from "pkg-types";
+import { getCheckCmd } from "../../../../../app/cmds.js";
+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"];
+  await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+    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, linter = false, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  await executeCommand(
+    resolvedOptions.packageManager.command,
+    latest ? ["update", "--latest"] : ["update"],
+    {
+      cwd: resolvedOptions.cwd,
+      silent: resolvedOptions.silent
+    }
+  );
+  if (linter) {
+    await runCmd(await getCheckCmd(), ["--no-exit", "--no-progress"]);
+  }
+}
+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-detect.d.ts

@@ -0,0 +1,12 @@
+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/libs/sdk/sdk-impl/utils/pm/pm-detect.js

@@ -0,0 +1,99 @@
+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/libs/sdk/sdk-impl/utils/pm/pm-parse.d.ts

@@ -0,0 +1,8 @@
+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/libs/sdk/sdk-impl/utils/pm/pm-parse.js

@@ -0,0 +1,29 @@
+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/libs/sdk/sdk-impl/utils/pm/pm-types.d.ts

@@ -0,0 +1,43 @@
+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;
+}
+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/libs/sdk/sdk-impl/utils/pm/pm-utils.d.ts

@@ -0,0 +1,12 @@
+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"> & {
+    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/libs/sdk/sdk-impl/utils/pm/pm-utils.js

@@ -0,0 +1,86 @@
+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 = {}) {
+  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  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,
+    global: options.global ?? false
+  };
+}
+export function getWorkspaceArgs(options) {
+  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;
+  }
+}

package/bin/libs/sdk/sdk-mod.d.ts

@@ -72,8 +72,32 @@ export { BINARY_EXTS, BINARY_SET } from "./sdk-impl/utils/b-exts.js";
 export { isBinaryExt } from "./sdk-impl/utils/binary.js";
 export type { CommentStyle, FileExtension, CommentMapping } from "./sdk-impl/utils/comments.js";
 export { DEFAULT_COMMENT, COMMENT_MAP, getCommentPrefix } from "./sdk-impl/utils/comments.js";
+export { notFoundError, hookChildProcess, verifyENOENT, verifyENOENTSync, } from "./sdk-impl/utils/exec/exec-enoent.js";
+export type { EnvLike, EnvPathInfo } from "./sdk-impl/utils/exec/exec-env.js";
+export { computeEnv } from "./sdk-impl/utils/exec/exec-env.js";
+export { NonZeroExitError } from "./sdk-impl/utils/exec/exec-error.js";
+export { escapeCommand, escapeArgument } from "./sdk-impl/utils/exec/exec-escape.js";
+export type { Output, PipeOptions, KillSignal, OutputApi, Result, Options, XExec, } from "./sdk-impl/utils/exec/exec-mod.js";
+export { ExecProcess, x, exec } from "./sdk-impl/utils/exec/exec-mod.js";
+export { parse } from "./sdk-impl/utils/exec/exec-parse.js";
+export { resolveCommand } from "./sdk-impl/utils/exec/exec-resolve.js";
+export { readShebang } from "./sdk-impl/utils/exec/exec-shebang.js";
+export { spawn, spawnSync } from "./sdk-impl/utils/exec/exec-spawn.js";
+export { waitForEvent, combineStreams } from "./sdk-impl/utils/exec/exec-stream.js";
+export type { ExecParseResult } from "./sdk-impl/utils/exec/exec-types.js";
+export { _parse } from "./sdk-impl/utils/exec/exec-types.js";
 export { detectFileType, detectBufferType, detectStreamType, isBinary, getMimeType, } from "./sdk-impl/utils/file-type.js";
 export { finalizeBuild, finalizePub } from "./sdk-impl/utils/finalize.js";
+export { safeRename, prepareCLIFiles } from "./sdk-impl/utils/fs-rename.js";
+export { FILE_TYPES, INIT_BEHAVIOURS, DEST_FILE_EXISTS_BEHAVIOURS, CONTENT_CREATE_MODES, } from "./sdk-impl/utils/init/init-const.js";
+export { createFileFromScratch, initFile, initFiles, escapeMarkdownCodeBlocks, } from "./sdk-impl/utils/init/init-impl.js";
+export { gitignoreTemplate, readmeTemplate, licenseTemplate, } from "./sdk-impl/utils/init/init-tmpl.js";
+export type { FileType, InitBehaviour, DestFileExistsBehaviour, ReinitUserConfig, InitFileRequest, InitFileOptions, InitFileResult, } from "./sdk-impl/utils/init/init-types.js";
+export { installDependencies, addDependency, addDevDependency, removeDependency, ensureDependencyInstalled, dedupeDependencies, updateDependencies, runScript, } from "./sdk-impl/utils/pm/pm-api.js";
+export { packageManagers, detectPackageManager } from "./sdk-impl/utils/pm/pm-detect.js";
+export { findup, parsePackageManagerField } from "./sdk-impl/utils/pm/pm-parse.js";
+export type { PackageManagerName, PackageManager, OperationOptions, DetectPackageManagerOptions, } from "./sdk-impl/utils/pm/pm-types.js";
+export { executeCommand, NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG, resolveOperationOptions, getWorkspaceArgs, doesDependencyExist, } from "./sdk-impl/utils/pm/pm-utils.js";
 export { resolveCrossLibs, resolveAllCrossLibs } from "./sdk-impl/utils/resolve-cross-libs.js";
 export { useAggregator } from "./sdk-impl/utils/tools-agg.js";
 export { printUsage } from "./sdk-impl/utils/tools-impl.js";

package/bin/libs/sdk/sdk-mod.js

@@ -155,6 +155,22 @@ export { shouldIgnoreFile, getAllFiles, getLineNumber } from "./sdk-impl/rules/r
 export { BINARY_EXTS, BINARY_SET } from "./sdk-impl/utils/b-exts.js";
 export { isBinaryExt } from "./sdk-impl/utils/binary.js";
 export { DEFAULT_COMMENT, COMMENT_MAP, getCommentPrefix } from "./sdk-impl/utils/comments.js";
+export {
+  notFoundError,
+  hookChildProcess,
+  verifyENOENT,
+  verifyENOENTSync
+} from "./sdk-impl/utils/exec/exec-enoent.js";
+export { computeEnv } from "./sdk-impl/utils/exec/exec-env.js";
+export { NonZeroExitError } from "./sdk-impl/utils/exec/exec-error.js";
+export { escapeCommand, escapeArgument } from "./sdk-impl/utils/exec/exec-escape.js";
+export { ExecProcess, x, exec } from "./sdk-impl/utils/exec/exec-mod.js";
+export { parse } from "./sdk-impl/utils/exec/exec-parse.js";
+export { resolveCommand } from "./sdk-impl/utils/exec/exec-resolve.js";
+export { readShebang } from "./sdk-impl/utils/exec/exec-shebang.js";
+export { spawn, spawnSync } from "./sdk-impl/utils/exec/exec-spawn.js";
+export { waitForEvent, combineStreams } from "./sdk-impl/utils/exec/exec-stream.js";
+export { _parse } from "./sdk-impl/utils/exec/exec-types.js";
 export {
   detectFileType,
   detectBufferType,
@@ -163,6 +179,43 @@ export {
   getMimeType
 } from "./sdk-impl/utils/file-type.js";
 export { finalizeBuild, finalizePub } from "./sdk-impl/utils/finalize.js";
+export { safeRename, prepareCLIFiles } from "./sdk-impl/utils/fs-rename.js";
+export {
+  FILE_TYPES,
+  INIT_BEHAVIOURS,
+  DEST_FILE_EXISTS_BEHAVIOURS,
+  CONTENT_CREATE_MODES
+} from "./sdk-impl/utils/init/init-const.js";
+export {
+  createFileFromScratch,
+  initFile,
+  initFiles,
+  escapeMarkdownCodeBlocks
+} from "./sdk-impl/utils/init/init-impl.js";
+export {
+  gitignoreTemplate,
+  readmeTemplate,
+  licenseTemplate
+} from "./sdk-impl/utils/init/init-tmpl.js";
+export {
+  installDependencies,
+  addDependency,
+  addDevDependency,
+  removeDependency,
+  ensureDependencyInstalled,
+  dedupeDependencies,
+  updateDependencies,
+  runScript
+} from "./sdk-impl/utils/pm/pm-api.js";
+export { packageManagers, detectPackageManager } from "./sdk-impl/utils/pm/pm-detect.js";
+export { findup, parsePackageManagerField } from "./sdk-impl/utils/pm/pm-parse.js";
+export {
+  executeCommand,
+  NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG,
+  resolveOperationOptions,
+  getWorkspaceArgs,
+  doesDependencyExist
+} from "./sdk-impl/utils/pm/pm-utils.js";
 export { resolveCrossLibs, resolveAllCrossLibs } from "./sdk-impl/utils/resolve-cross-libs.js";
 export { useAggregator } from "./sdk-impl/utils/tools-agg.js";
 export { printUsage } from "./sdk-impl/utils/tools-impl.js";

package/package.json

@@ -14,36 +14,37 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/pluginutils": "^5.2.0",
-    "@sinclair/typebox": "^0.34.37",
+    "@sinclair/typebox": "^0.34.38",
     "autoprefixer": "^10.4.21",
     "bun-plugin-tailwind": "^0.0.15",
-    "c12": "^3.0.4",
+    "c12": "^3.1.0",
     "confbox": "^0.2.2",
-    "cssnano": "^7.0.7",
+    "cssnano": "^7.1.0",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
-    "esbuild": "^0.25.5",
+    "esbuild": "^0.25.6",
     "execa": "^9.6.0",
     "file-type": "^21.0.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
     "hookable": "^5.5.3",
     "jiti": "^2.4.2",
-    "jsonrepair": "^3.12.0",
+    "jsonrepair": "^3.13.0",
     "lookpath": "^1.2.3",
     "magic-string": "^0.30.17",
     "mlly": "^1.7.4",
-    "nypm": "^0.6.0",
     "p-all": "^5.0.0",
     "p-map": "^7.0.3",
+    "path-key": "^4.0.0",
     "pkg-types": "^2.2.0",
     "postcss": "^8.5.6",
     "postcss-nested": "^7.0.2",
     "pretty-bytes": "^7.0.0",
     "pretty-ms": "^9.2.0",
-    "rollup": "^4.44.1",
+    "rollup": "^4.45.1",
     "rollup-plugin-dts": "^6.2.1",
     "scule": "^1.3.0",
     "semver": "^7.7.2",
+    "shebang-command": "^2.0.0",
     "strip-json-comments": "^5.0.2",
     "tinyglobby": "^0.2.14",
     "ts-morph": "^26.0.0",
@@ -54,7 +55,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.60",
+  "version": "1.7.61",
   "keywords": [
     "reliverse",
     "cli",