@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/utils/schemaTemplate.js

@@ -1,98 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs, { ensuredir } from "@reliverse/relifso";
-import { cliHomeRepos, cliVersion } from "../config/constants.js";
-export const DEFAULT_REPOS_CONFIG = {
-  $schema: "./schema.json",
-  version: cliVersion,
-  repos: []
-};
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isRepoInfo(value) {
-  if (!isObject(value)) return false;
-  const v = value;
-  const github = v.github;
-  return typeof v.id === "string" && typeof v.author === "string" && typeof v.name === "string" && typeof v.description === "string" && typeof v.category === "string" && typeof v.lastUpdated === "string" && typeof v.localPath === "string" && isObject(github) && typeof github.stars === "number" && typeof github.forks === "number" && typeof github.watchers === "number" && typeof github.createdAt === "string" && typeof github.updatedAt === "string" && typeof github.pushedAt === "string" && typeof github.defaultBranch === "string";
-}
-export function isReposConfig(value) {
-  if (!isObject(value)) return false;
-  const v = value;
-  return typeof v.$schema === "string" && typeof v.version === "string" && Array.isArray(v.repos) && v.repos.every((r) => isRepoInfo(r));
-}
-export async function generateReposJsonSchema() {
-  const schema = {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    title: "rse Repos Schema",
-    description: "Schema for repos.json configuration file",
-    type: "object",
-    properties: {
-      $schema: { type: "string" },
-      version: { type: "string" },
-      repos: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string" },
-            author: { type: "string" },
-            name: { type: "string" },
-            description: { type: "string" },
-            category: { type: "string" },
-            lastUpdated: { type: "string" },
-            localPath: { type: "string" },
-            github: {
-              type: "object",
-              properties: {
-                stars: { type: "number" },
-                forks: { type: "number" },
-                watchers: { type: "number" },
-                createdAt: { type: "string" },
-                updatedAt: { type: "string" },
-                pushedAt: { type: "string" },
-                defaultBranch: { type: "string" }
-              },
-              required: [
-                "stars",
-                "forks",
-                "watchers",
-                "createdAt",
-                "updatedAt",
-                "pushedAt",
-                "defaultBranch"
-              ]
-            }
-          },
-          required: [
-            "id",
-            "author",
-            "name",
-            "description",
-            "category",
-            "lastUpdated",
-            "localPath",
-            "github"
-          ]
-        }
-      }
-    },
-    required: ["$schema", "version", "repos"],
-    additionalProperties: false
-  };
-  await ensuredir(cliHomeRepos);
-  const schemaPath = path.join(cliHomeRepos, "schema.json");
-  await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2));
-}
-export async function shouldRegenerateSchema() {
-  const configPath = path.join(cliHomeRepos, "repos.json");
-  if (!await fs.pathExists(configPath)) {
-    return true;
-  }
-  try {
-    const content = await fs.readFile(configPath, "utf-8");
-    const config = JSON.parse(content);
-    return config.version !== cliVersion;
-  } catch {
-    return true;
-  }
-}

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

@@ -1,8 +0,0 @@
-export declare function readLocalPackageJSON(): Promise<{
-    name?: string;
-    version?: string;
-}>;
-export declare const getPkgName: () => Promise<string>;
-export declare const getPkgVersion: () => Promise<string>;
-export declare function showStartPrompt(isDev: boolean, showRuntimeInfo: boolean, clearConsole: boolean): Promise<void>;
-export declare function showEndPrompt(): Promise<void>;

package/bin/impl/utils/startEndPrompts.js

@@ -1,53 +0,0 @@
-import { dirname } from "node:path";
-import { relinka } from "@reliverse/relinka";
-import { endPrompt, startPrompt } from "@reliverse/rempts";
-import { isBun, isBunPM, isBunRuntime } from "@reliverse/runtime";
-import { readPackageJSON } from "pkg-types";
-import { cliVersion, dlerName } from "../config/constants.js";
-export async function readLocalPackageJSON() {
-  const candidateDirs = [];
-  if (Array.isArray(process.argv) && typeof process.argv[1] === "string" && process.argv[1].length > 0) {
-    candidateDirs.push(dirname(process.argv[1]));
-  }
-  candidateDirs.push(process.cwd());
-  for (const dir of candidateDirs) {
-    try {
-      const pkg = await readPackageJSON(dir);
-      return { name: pkg.name, version: pkg.version };
-    } catch {
-    }
-  }
-  relinka("verbose", "Could not read package.json, using default values");
-  return {};
-}
-export const getPkgName = async () => {
-  const pkg = await readLocalPackageJSON();
-  return pkg.name || "unknown";
-};
-export const getPkgVersion = async () => {
-  const pkg = await readLocalPackageJSON();
-  return pkg.version || "0.0.0";
-};
-export async function showStartPrompt(isDev, showRuntimeInfo, clearConsole) {
-  await startPrompt({
-    titleColor: "inverse",
-    clearConsole,
-    packageName: dlerName,
-    packageVersion: cliVersion,
-    isDev
-  });
-  if (showRuntimeInfo) {
-    console.log("isBunRuntime:", isBunRuntime());
-    console.log("isBunPM:", await isBunPM());
-    console.log("isBun:", isBun);
-  }
-}
-export async function showEndPrompt() {
-  await endPrompt({
-    title: "Please consider supporting Reliverse development: https://github.com/sponsors/blefnk",
-    titleAnimation: "glitch",
-    titleColor: "dim",
-    titleTypography: "bold",
-    titleAnimationDelay: 800
-  });
-}

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

@@ -1,19 +0,0 @@
-export declare const handleError: (error: unknown) => string;
-/**
- * Changes the current working directory to the specified path.
- * Logs a warning if the target directory does not exist.
- */
-export declare function cd(dir: string): Promise<void>;
-/**
- * Returns the current working directory.
- */
-export declare function pwd(): void;
-/**
- * Removes a file or directory (recursively, if it's a directory).
- * Logs an error if removal fails.
- */
-export declare function rm(target: string): Promise<void>;
-/**
- * Returns the current working directory.
- */
-export declare function getCurrentWorkingDirectory(useCache?: boolean): string;

package/bin/impl/utils/terminalHelpers.js

@@ -1,43 +0,0 @@
-import { cwd } from "node:process";
-import { normalize } from "@reliverse/pathkit";
-import fs, { ensuredir } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-export const handleError = (error) => error instanceof Error ? error.message : "Unknown error";
-export async function cd(dir) {
-  try {
-    await ensuredir(dir);
-    await fs.access(dir);
-    process.chdir(dir);
-    relinka("verbose", `Changed directory to: ${process.cwd()}`);
-  } catch (error) {
-    relinka("warn", `Directory does not exist: ${dir}`, handleError(error));
-  }
-}
-export function pwd() {
-  const cwd2 = getCurrentWorkingDirectory();
-  relinka("verbose", `Current working directory: ${cwd2}`);
-}
-export async function rm(target) {
-  try {
-    await fs.remove(target);
-    relinka("verbose", `Removed: ${target}`);
-  } catch (error) {
-    relinka("error", `Failed to remove: ${target}`, handleError(error));
-  }
-}
-export function getCurrentWorkingDirectory(useCache = true) {
-  let cachedCWD = null;
-  if (useCache && cachedCWD) {
-    return cachedCWD;
-  }
-  try {
-    const currentDirectory = normalize(cwd());
-    if (useCache) {
-      cachedCWD = currentDirectory;
-    }
-    return currentDirectory;
-  } catch (error) {
-    relinka("error", "Error getting current working directory:", handleError(error));
-    throw error;
-  }
-}

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

@@ -1,5 +0,0 @@
-import type { ParamsOmitReli } from "../types/mod.js";
-/**
- * Sets up the dev environment if the isDev flag is true.
- */
-export declare function setupDevModeIfNeeded(params: ParamsOmitReli): Promise<void>;

package/bin/impl/utils/testsRuntime.js

@@ -1,11 +0,0 @@
-import path from "@reliverse/pathkit";
-import { ensuredir } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-export async function setupDevModeIfNeeded(params) {
-  if (params.isDev) {
-    const newCwd = path.join(params.cwd, "tests-runtime");
-    await ensuredir(newCwd);
-    params.cwd = newCwd;
-    relinka("verbose", `Dev mode: using tests-runtime => ${newCwd}`);
-  }
-}

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

@@ -1,5 +0,0 @@
-/**
- * Searches upward from the given path for a tsconfig.json.
- * Returns the full path if found, otherwise undefined.
- */
-export declare function findTsconfigUp(fromPath: string): Promise<string | undefined>;

package/bin/impl/utils/tsconfigHelpers.js

@@ -1,14 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-export async function findTsconfigUp(fromPath) {
-  let currentDir = fromPath;
-  const rootPath = path.parse(currentDir).root;
-  while (true) {
-    const candidate = path.join(currentDir, "tsconfig.json");
-    if (await fs.pathExists(candidate)) return candidate;
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir || currentDir === rootPath) break;
-    currentDir = parentDir;
-  }
-  return;
-}

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

@@ -1,33 +0,0 @@
-import type { NpmOutExt, ReliverseConfig, Sourcemap } from "../schema/mod.js";
-/**
- * Converts the Unified build sourcemap option to a Bun-friendly value.
- * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
- * @returns "none", "inline", or "external" for Bun's bundler.
- */
-export declare function getBunSourcemapOption(transpileSourcemap: Sourcemap): "external" | "inline" | "none";
-/**
- * Converts the Unified build sourcemap option to a Rollup/Unified-bundler friendly value.
- * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
- * @returns "inline" if inline is specified; true for linked/external or boolean true; otherwise false.
- */
-export declare function getUnifiedSourcemapOption(transpileSourcemap: Sourcemap): "inline" | boolean;
-/**
- * Renames the primary output file (and its declaration file, if applicable)
- * in the output directory.
- *
- * @deprecated Earlier dler used to rename to a standardized name (e.g., mod.js, mod.ts).
- *
- * TODO: It will be removed in the future.
- *
- * @param isJsr - Flag indicating if the target platform is JSR.
- * @param outDirBin - The output directory where the compiled files reside.
- * @param originalEntryFileBasename - The base name (file name only) of the original entry file processed by the bundler.
- * @param unifiedBundlerOutExt - The file extension used for standard (non-JSR) builds (e.g., 'js', 'mjs').
- * @param distJsrOutFilesExt - The file extension used for JSR builds (likely 'ts' or 'js').
- * @param config - The configuration object.
- * @returns An object containing the new base name of the entry file.
- * @throws If the expected source entry file is not found in the output directory.
- */
-export declare function renameEntryFile(isJsr: boolean, outDirBin: string, originalEntryFileBasename: string, unifiedBundlerOutExt: NpmOutExt, distJsrOutFilesExt: NpmOutExt, config: ReliverseConfig): Promise<{
-    updatedEntryFile: string;
-}>;

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

@@ -1,97 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-export function getBunSourcemapOption(transpileSourcemap) {
-  relinka("verbose", `Converting Bun sourcemap option from: ${transpileSourcemap}`);
-  switch (transpileSourcemap) {
-    case "inline":
-      return "inline";
-    case "none":
-    case false:
-      return "none";
-    default:
-      return "external";
-  }
-}
-export function getUnifiedSourcemapOption(transpileSourcemap) {
-  relinka("verbose", `Converting Unified/Rollup sourcemap option from: ${transpileSourcemap}`);
-  switch (transpileSourcemap) {
-    case "external":
-    case "linked":
-      return true;
-    // Indicates separate sourcemap file
-    case "inline":
-      return "inline";
-    // Indicates inline sourcemap
-    case "none":
-    case false:
-      return false;
-    // No sourcemap
-    default:
-      return !!transpileSourcemap;
-  }
-}
-export async function renameEntryFile(isJsr, outDirBin, originalEntryFileBasename, unifiedBundlerOutExt, distJsrOutFilesExt, config) {
-  relinka(
-    "verbose",
-    `Attempting to rename entry file. Original basename: ${originalEntryFileBasename}, Output Dir: ${outDirBin}, isJsr=${isJsr}`
-  );
-  let sourceEntryBasename;
-  let targetEntryBasename;
-  let sourceDeclarationBasename = null;
-  let targetDeclarationBasename = null;
-  const outputExt = isJsr ? distJsrOutFilesExt : unifiedBundlerOutExt;
-  const originalBasenameNoExt = originalEntryFileBasename.split(".").slice(0, -1).join(".");
-  if (isJsr) {
-    if (originalEntryFileBasename.endsWith(".ts")) {
-      sourceEntryBasename = originalEntryFileBasename;
-      targetEntryBasename = config.coreEntryFile;
-    } else {
-      sourceEntryBasename = `${originalBasenameNoExt}.${outputExt}`;
-      targetEntryBasename = `${config.coreEntryFile.replace(/\.ts$/, `.${outputExt}`)}`;
-    }
-  } else {
-    sourceEntryBasename = `${originalBasenameNoExt}.${outputExt}`;
-    targetEntryBasename = `${config.coreEntryFile.replace(/\.ts$/, `.${outputExt}`)}`;
-    sourceDeclarationBasename = `${originalBasenameNoExt}.d.ts`;
-    targetDeclarationBasename = `${config.coreEntryFile.replace(/\.ts$/, ".d.ts")}`;
-  }
-  const sourceEntryPath = path.join(outDirBin, sourceEntryBasename);
-  const targetEntryPath = path.join(outDirBin, targetEntryBasename);
-  const sourceDeclarationPath = sourceDeclarationBasename ? path.join(outDirBin, sourceDeclarationBasename) : null;
-  const targetDeclarationPath = targetDeclarationBasename ? path.join(outDirBin, targetDeclarationBasename) : null;
-  if (!await fs.pathExists(sourceEntryPath)) {
-    throw new Error(`Entry file expected for renaming not found: ${sourceEntryPath}`);
-  }
-  relinka(
-    "verbose",
-    `Found source entry file: ${sourceEntryPath}. Renaming to: ${targetEntryPath}`
-  );
-  if (sourceDeclarationPath && targetDeclarationPath) {
-    if (await fs.pathExists(sourceDeclarationPath)) {
-      if (sourceDeclarationPath !== targetDeclarationPath) {
-        relinka(
-          "verbose",
-          `Renaming declaration ${sourceDeclarationPath} to ${targetDeclarationPath}`
-        );
-        await fs.rename(sourceDeclarationPath, targetDeclarationPath);
-      } else {
-      }
-    } else {
-      relinka(
-        "verbose",
-        `Source declaration file not found, skipping rename: ${sourceDeclarationPath}`
-      );
-    }
-  }
-  if (sourceEntryPath !== targetEntryPath) {
-    await fs.rename(sourceEntryPath, targetEntryPath);
-    relinka("verbose", `Renamed entry file to ${targetEntryPath}`);
-  } else {
-    relinka(
-      "log",
-      `Source entry file ${sourceEntryPath} already has the target name. Skipping rename.`
-    );
-  }
-  return { updatedEntryFile: targetEntryBasename };
-}

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

@@ -1,11 +0,0 @@
-import type { LibConfig } from "../schema/mod.js";
-/**
- * Recursively removes any existing distribution folders.
- */
-export declare function removeDistFolders(distNpmDirName: string, distJsrDirName: string, libsDirDist: string, libsList: Record<string, LibConfig>, distTmpDirName?: string): Promise<boolean>;
-/**
- * Removes logInternal and relinka "internal" calls from TypeScript/JavaScript files
- * @param targetDir Directory to process recursively
- * @returns Promise<boolean> True if successful
- */
-export declare function removeLogInternalCalls(targetDir: string): Promise<boolean>;

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

@@ -1,70 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
-export async function removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList, distTmpDirName = "") {
-  const foldersToRemove = [];
-  foldersToRemove.push(distNpmDirName);
-  foldersToRemove.push(distJsrDirName);
-  if (distTmpDirName !== "") {
-    foldersToRemove.push(distTmpDirName);
-  }
-  if (libsList && Object.keys(libsList).length > 0) {
-    foldersToRemove.push(libsDirDist);
-  }
-  const existingFolders = [];
-  for (const folder of foldersToRemove) {
-    const folderPath = path.resolve(PROJECT_ROOT, folder);
-    if (await fs.pathExists(folderPath)) {
-      existingFolders.push(folder);
-    }
-  }
-  if (existingFolders.length > 0) {
-    await pMap(
-      existingFolders,
-      async (folder) => {
-        const folderPath = path.resolve(PROJECT_ROOT, folder);
-        if (await fs.pathExists(folderPath)) {
-          await fs.remove(folderPath);
-          relinka("verbose", `Removed: ${folderPath}`);
-        }
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-    );
-    relinka("verbose", "Distribution folders removed successfully");
-  }
-  return true;
-}
-export async function removeLogInternalCalls(targetDir) {
-  const files = await fs.readdir(targetDir, { recursive: true });
-  const tsJsFiles = files.filter(
-    (file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")
-  );
-  await pMap(
-    tsJsFiles,
-    async (file) => {
-      const filePath = path.join(targetDir, file);
-      const content = await fs.readFile(filePath, "utf8");
-      let newContent = content.replace(
-        /logInternal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(
-        /relinka\s*\(\s*["']internal["']\s*,\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(
-        /relinka\.internal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(/\n\s*\n\s*\n/g, "\n\n").replace(/^\s*\n/gm, "").replace(/\n\s*$/g, "\n");
-      if (newContent !== content) {
-        await fs.writeFile(filePath, newContent);
-      }
-    },
-    { concurrency: CONCURRENCY_DEFAULT }
-  );
-  relinka("verbose", "Successfully removed logInternal and relinka internal calls from files");
-  return true;
-}

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

@@ -1,5 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * Filters out development dependencies from a dependency record.
- */
-export declare function filterDeps(deps: Record<string, string> | undefined, clearUnused: boolean, outDirBin: string, isJsr: boolean, config: ReliverseConfig, libName?: string): Promise<Record<string, string>>;

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

@@ -1,126 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON } from "pkg-types";
-import { glob } from "tinyglobby";
-import { readFileSafe } from "./utils-fs.js";
-import { extractPackageName } from "./utils-misc.js";
-export async function filterDeps(deps, clearUnused, outDirBin, isJsr, config, libName) {
-  relinka("verbose", `Filtering dependencies (clearUnused=${clearUnused})`);
-  if (!deps) return {};
-  const patterns = /* @__PURE__ */ new Set();
-  const addPatterns = /* @__PURE__ */ new Set();
-  for (const pattern of config.filterDepsPatterns.global) {
-    if (pattern.startsWith("+")) {
-      addPatterns.add(pattern.slice(1));
-    } else {
-      patterns.add(pattern);
-    }
-  }
-  if (!isJsr) {
-    for (const pattern of config.filterDepsPatterns["dist-npm"]) {
-      if (pattern.startsWith("+")) {
-        addPatterns.add(pattern.slice(1));
-      } else {
-        patterns.add(pattern);
-      }
-    }
-  }
-  if (isJsr) {
-    for (const pattern of config.filterDepsPatterns["dist-jsr"]) {
-      if (pattern.startsWith("+")) {
-        addPatterns.add(pattern.slice(1));
-      } else {
-        patterns.add(pattern);
-      }
-    }
-  }
-  if (libName && config.filterDepsPatterns["dist-libs"][libName]) {
-    const libPatterns = config.filterDepsPatterns["dist-libs"][libName];
-    if (!isJsr) {
-      for (const pattern of libPatterns.npm) {
-        if (pattern.startsWith("+")) {
-          addPatterns.add(pattern.slice(1));
-        } else {
-          patterns.add(pattern);
-        }
-      }
-    }
-    if (isJsr) {
-      for (const pattern of libPatterns.jsr) {
-        if (pattern.startsWith("+")) {
-          addPatterns.add(pattern.slice(1));
-        } else {
-          patterns.add(pattern);
-        }
-      }
-    }
-  }
-  const shouldExcludeByPattern = (depName) => {
-    const depNameLower = depName.toLowerCase();
-    for (const pattern of patterns) {
-      if (pattern.startsWith("!")) {
-        const negPattern = pattern.slice(1).toLowerCase();
-        if (depNameLower.includes(negPattern)) {
-          return false;
-        }
-      }
-    }
-    for (const pattern of patterns) {
-      if (!pattern.startsWith("!")) {
-        if (depNameLower.includes(pattern.toLowerCase())) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-  const originalPkg = await readPackageJSON();
-  const shouldExcludeDep = (depName, isDevDep) => {
-    if (isJsr && config.coreIsCLI.enabled) {
-      return shouldExcludeByPattern(depName);
-    }
-    return isDevDep || shouldExcludeByPattern(depName);
-  };
-  const devDeps = deps === originalPkg.devDependencies;
-  if (!clearUnused) {
-    const filtered2 = Object.entries(deps).reduce((acc, [k, v]) => {
-      if (!shouldExcludeDep(k, devDeps)) {
-        acc[k] = v;
-      }
-      return acc;
-    }, {});
-    for (const pattern of addPatterns) {
-      if (!filtered2[pattern] && !originalPkg.dependencies?.[pattern]) {
-        filtered2[pattern] = originalPkg.devDependencies?.[pattern] || "latest";
-      }
-    }
-    relinka("verbose", `Filtered dependencies count: ${Object.keys(filtered2).length}`);
-    return filtered2;
-  }
-  const files = await glob("**/*.{js,ts}", {
-    absolute: true,
-    cwd: outDirBin
-  });
-  const usedPackages = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const content = await readFileSafe(file, isJsr, "filterDeps");
-    const importMatches = content.matchAll(/from\s+['"](\.|\.\/|\.\\)?src(\/|\\)/g);
-    for (const match of importMatches) {
-      const importPath = match[1];
-      const pkg = extractPackageName(importPath);
-      if (pkg) {
-        usedPackages.add(pkg);
-      }
-    }
-  }
-  const filtered = Object.entries(deps).reduce((acc, [k, v]) => {
-    if (usedPackages.has(k) && !shouldExcludeDep(k, devDeps)) {
-      acc[k] = v;
-    }
-    return acc;
-  }, {});
-  relinka(
-    "verbose",
-    `Filtered dependencies count (after usage check): ${Object.keys(filtered).length}`
-  );
-  return filtered;
-}

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

@@ -1,12 +0,0 @@
-import type { LibConfig } from "../schema/mod.js";
-/**
- * Determines the distribution name based on the file path and build type.
- * This function is used for logging and determining output paths.
- *
- * @returns The distribution name in the transpileFormat of:
- *   - For empty isJsr: "root"
- *   - For regular builds: "dist-jsr" or "dist-npm"
- *   - For library builds: "dist-libs/{lib-name}/jsr" or "dist-libs/{lib-name}/npm"
- *   - For library builds with libDirName: "dist-libs/{libDirName}/jsr" or "dist-libs/{libDirName}/npm"
- */
-export declare function determineDistName(filePath: string, isJsr: "" | boolean, libsList?: Record<string, LibConfig>): string;

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

@@ -1,25 +0,0 @@
-export function determineDistName(filePath, isJsr, libsList) {
-  if (isJsr === "") {
-    return "root";
-  }
-  const baseDistName = isJsr ? "dist-jsr" : "dist-npm";
-  const isLibraryPath = filePath.includes("/libs/") || filePath.includes("\\libs\\");
-  if (!isLibraryPath) {
-    return baseDistName;
-  }
-  const libPathRegex = /[/\\]libs[/\\]([^/\\]+)/;
-  const libPathResult = libPathRegex.exec(filePath);
-  const extractedLibName = libPathResult?.[1];
-  if (!extractedLibName) {
-    return baseDistName;
-  }
-  if (libsList) {
-    for (const [libName, libConfig] of Object.entries(libsList)) {
-      const simplifiedLibName = libName.startsWith("@") ? libName.split("/")[1] : libName;
-      if (simplifiedLibName === extractedLibName && libConfig.libDirName) {
-        return isJsr ? `dist-libs/${libConfig.libDirName}/jsr` : `dist-libs/${libConfig.libDirName}/npm`;
-      }
-    }
-  }
-  return isJsr ? `dist-libs/${extractedLibName}/jsr` : `dist-libs/${extractedLibName}/npm`;
-}

package/bin/impl/utils/utils-error-cwd.d.ts

@@ -1,19 +0,0 @@
-/**
- * Handles errors during the build process.
- * This is the single source of error logging.
- */
-export declare function handleDlerError(error: unknown): never;
-/**
- * Runs an async function within a given working directory,
- * ensuring that the original directory is restored afterward.
- */
-export declare function withWorkingDirectory<T>(transpileTargetDir: string, fn: () => Promise<T>): Promise<T>;
-/**
- * Validates that the current working directory is appropriate for a development environment.
- * Throws an error if the current directory does not contain any of the required paths.
- */
-export declare function validateDevCwd(isDev: boolean, paths: string[], cliName: string, cliOrg?: string): Promise<void>;
-/**
- * Converts unknown errors to readable strings.
- */
-export declare const formatError: (error: unknown) => string;