@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/utils/utils-error-cwd.js

@@ -1,49 +0,0 @@
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-import { ExecaError } from "execa";
-export function handleDlerError(error) {
-  let rootCause = "";
-  if (error instanceof ExecaError) {
-    rootCause = error.message;
-  } else if (error instanceof Error) {
-    rootCause = error.message;
-  }
-  relinka("error", re.bold("Unexpected error happened:"));
-  if (rootCause) {
-    relinka("error", re.italic(rootCause));
-  }
-  process.exit(1);
-}
-export async function withWorkingDirectory(transpileTargetDir, fn) {
-  const originalDir = process.cwd();
-  try {
-    process.chdir(transpileTargetDir);
-    relinka("verbose", `CWD (current working directory): ${originalDir} -> ${transpileTargetDir}`);
-    const result = await fn();
-    return result;
-  } catch (error) {
-    relinka("null", "");
-    relinka("error", re.italic(transpileTargetDir), error);
-    throw error;
-  } finally {
-    process.chdir(originalDir);
-    relinka("verbose", `CWD (current working directory): ${transpileTargetDir} -> ${originalDir}`);
-  }
-}
-export async function validateDevCwd(isDev, paths, cliName, cliOrg = "") {
-  if (!isDev) return;
-  const projectName = cliOrg ? `@${cliOrg}/${cliName}` : cliName;
-  const currentDir = process.cwd();
-  if (!paths.some((path) => currentDir.includes(path))) {
-    const pathsList = paths.map((p) => `'${p}'`).join(", ");
-    throw new Error(
-      [
-        `\u2502  The '--dev' flag is reserved exclusively for ${projectName} developers`,
-        `\u2502  Your current directory must include one of the following paths: ${pathsList}`,
-        `\u2502  Also please make sure to use 'bun dev' instead of '${cliName} --dev'`,
-        `\u2502  Current working directory: ${currentDir}`
-      ].join("\n")
-    );
-  }
-}
-export const formatError = (error) => error instanceof Error ? error.message : String(error);

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

@@ -1,25 +0,0 @@
-/**
- * Copies specified files from the root directory to the output directory.
- */
-export declare function copyRootFile(outDirRoot: string, fileNames: string[]): Promise<void>;
-/**
- * Calculates the total size (in bytes) of a directory.
- */
-export declare function getDirectorySize(outDirRoot: string, isDev: boolean): Promise<number>;
-/**
- * Recursively counts the number of files in a directory.
- */
-export declare function outDirBinFilesCount(outDirBin: string): Promise<number>;
-/**
- * Deletes specific test and temporary files from a given directory.
- */
-export declare function deleteSpecificFiles(outDirBin: string): Promise<void>;
-/**
- * Reads a file safely and returns its content.
- */
-export declare function readFileSafe(filePath: string, isJsr: "" | boolean, reason: string): Promise<string>;
-/**
- * Writes content to a file safely.
- */
-export declare function writeFileSafe(filePath: string, content: string, reason: string): Promise<void>;
-export declare function validateDirectory(dir: string): Promise<boolean>;

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

@@ -1,183 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { glob } from "tinyglobby";
-import { CONCURRENCY_DEFAULT, SHOW_VERBOSE } from "../config/constants.js";
-import { determineDistName } from "./utils-determine.js";
-export async function copyRootFile(outDirRoot, fileNames) {
-  if (fileNames.length === 0) {
-    return;
-  }
-  const EXCLUDED_FILES = ["bin", "jsr.json", "jsr.jsonc", "package.json"];
-  try {
-    await fs.ensureDir(outDirRoot);
-    const specialFileHandlers = {
-      LICENSE: {
-        variants: ["LICENSE", "LICENSE.md", "LICENSES"]
-      },
-      README: {
-        variants: ["README.md", "README"]
-      }
-    };
-    await pMap(
-      fileNames,
-      async (fileName) => {
-        try {
-          if (EXCLUDED_FILES.includes(fileName)) {
-            relinka(
-              "verbose",
-              `The following artifact is auto-generated in dist and will not be copied from the root: ${fileName}`
-            );
-            return;
-          }
-          const specialConfig = specialFileHandlers[fileName];
-          if (specialConfig?.variants) {
-            for (const variant of specialConfig.variants) {
-              const file = await findFileCaseInsensitive(variant);
-              if (file) {
-                const targetPath = path.join(outDirRoot, variant);
-                if (await fs.pathExists(targetPath)) {
-                  await fs.remove(targetPath);
-                }
-                await fs.copy(file, targetPath, { errorOnExist: true });
-                relinka("verbose", `Copied ${file} to ${outDirRoot}/${variant}`);
-              }
-            }
-          } else {
-            const file = await findFileCaseInsensitive(fileName);
-            if (file) {
-              const targetPath = path.join(outDirRoot, fileName);
-              if (await fs.pathExists(targetPath)) {
-                await fs.remove(targetPath);
-              }
-              await fs.copy(file, targetPath, { errorOnExist: true });
-              relinka("verbose", `Copied ${file} to ${outDirRoot}/${fileName}`);
-            }
-          }
-        } catch (fileError) {
-          relinka("error", `Failed to copy ${fileName}: ${fileError}`);
-        }
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-      // Process up to CONCURRENCY_DEFAULT files simultaneously
-    );
-  } catch (error) {
-    relinka("error", `Failed to copy files: ${error}`);
-    throw new Error(`File copying failed: ${error}`);
-  }
-}
-export async function getDirectorySize(outDirRoot, isDev) {
-  if (SHOW_VERBOSE.getDirectorySize) {
-    relinka("verbose", `Calculating directory size for: ${outDirRoot}`);
-  }
-  try {
-    const files = await fs.readdir(outDirRoot);
-    const sizes = await pMap(
-      files,
-      async (file) => {
-        const fp = path.join(outDirRoot, file);
-        const stats = await fs.stat(fp);
-        return stats.isDirectory() ? getDirectorySize(fp, isDev) : stats.size;
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-    );
-    const totalSize = sizes.reduce((total, s) => total + s, 0);
-    if (SHOW_VERBOSE.getDirectorySize) {
-      relinka("verbose", `Calculated directory size: ${totalSize} bytes for ${outDirRoot}`);
-    }
-    return totalSize;
-  } catch (error) {
-    relinka("error", `Failed to calculate directory size for ${outDirRoot}`, error);
-    return 0;
-  }
-}
-export async function outDirBinFilesCount(outDirBin) {
-  relinka("verbose", `Counting files in directory: ${outDirBin}`);
-  let fileCount = 0;
-  if (!await fs.pathExists(outDirBin)) {
-    relinka("error", `[outDirBinFilesCount] Directory does not exist: ${outDirBin}`);
-    return fileCount;
-  }
-  await fs.dive(outDirBin, () => {
-    fileCount++;
-  });
-  relinka("verbose", `Total file count in ${outDirBin}: ${fileCount}`);
-  return fileCount;
-}
-async function findFileCaseInsensitive(transpileTargetFile) {
-  const files = await fs.readdir(".");
-  const found = files.find((file) => file.toLowerCase() === transpileTargetFile.toLowerCase());
-  return found || null;
-}
-const TEST_FILE_PATTERNS = [
-  "**/*.test.js",
-  "**/*.test.ts",
-  "**/*.test.d.ts",
-  "**/*-temp.js",
-  "**/*-temp.ts",
-  "**/*-temp.d.ts",
-  "**/__snapshots__/**"
-];
-export async function deleteSpecificFiles(outDirBin) {
-  relinka("verbose", `Deleting test and temporary files in: ${outDirBin}`);
-  const files = await glob(TEST_FILE_PATTERNS, {
-    absolute: true,
-    cwd: outDirBin
-  });
-  const snapshotDirs = await glob("**/__snapshots__", {
-    absolute: true,
-    cwd: outDirBin,
-    onlyDirectories: true
-  });
-  const filesToDelete = files.filter((file) => {
-    if (file.endsWith(".d.ts")) {
-      return file.includes(".test.d.ts") || file.includes("-temp.d.ts");
-    }
-    return true;
-  });
-  if (filesToDelete.length > 0) {
-    await pMap(filesToDelete, async (file) => fs.remove(file), {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", `Deleted files:
-${filesToDelete.join("\n")}`);
-  }
-  if (snapshotDirs.length > 0) {
-    await pMap(snapshotDirs, async (dir) => fs.remove(dir), {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", `Deleted snapshot directories:
-${snapshotDirs.join("\n")}`);
-  }
-}
-export async function readFileSafe(filePath, isJsr, reason) {
-  const distName = determineDistName(filePath, isJsr, void 0);
-  try {
-    const content = await fs.readFile(filePath, "utf8");
-    if (SHOW_VERBOSE.readFileSafe) {
-      relinka("verbose", `[${distName}] Successfully read file: ${filePath} [Reason: ${reason}]`);
-    }
-    return content;
-  } catch (error) {
-    relinka("error", `[${distName}] Failed to read file: ${filePath} [Reason: ${reason}]`, error);
-    throw error;
-  }
-}
-export async function writeFileSafe(filePath, content, reason) {
-  try {
-    await fs.writeFile(filePath, content, "utf8");
-    relinka("verbose", `Successfully wrote file: ${filePath} [Reason: ${reason}]`);
-  } catch (error) {
-    relinka("error", `Failed to write file: ${filePath} [Reason: ${reason}]`, error);
-    throw error;
-  }
-}
-export async function validateDirectory(dir) {
-  try {
-    const stat = await fs.stat(dir);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}

package/bin/impl/utils/utils-jsr-json.d.ts

@@ -1,9 +0,0 @@
-import type { LibConfig, ReliverseConfig } from "../schema/mod.js";
-/**
- * Generates a jsr.json configuration file for JSR distributions.
- */
-export declare function createJsrJSON(outDirRoot: string, isLib: boolean, libsList: Record<string, LibConfig>, config: ReliverseConfig, libName?: string, pkgDescription?: string): Promise<void>;
-/**
- * Renames .tsx files by replacing the .tsx extension with -tsx.txt.
- */
-export declare function renameTsxFiles(dir: string): Promise<void>;

package/bin/impl/utils/utils-jsr-json.js

@@ -1,75 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { readPackageJSON } from "pkg-types";
-import { glob } from "tinyglobby";
-import { CONCURRENCY_DEFAULT, cliDomainDocs } from "../config/constants.js";
-export async function createJsrJSON(outDirRoot, isLib, libsList, config, libName = "unknown-lib-name", pkgDescription = "unknown-lib-description") {
-  relinka("verbose", `Creating jsr.json configuration (isLib: ${isLib})`);
-  const originalPkg = await readPackageJSON();
-  let { description, name } = originalPkg;
-  const { author, license, version } = originalPkg;
-  if (isLib) {
-    name = libName;
-    description = pkgDescription;
-    if (!libsList[libName]?.libMainFile) {
-      throw new Error(`libsList.${libName}.libMainFile is not defined for library ${libName}`);
-    }
-  }
-  const pkgHomepage = cliDomainDocs;
-  const jsrConfig = {
-    author,
-    description,
-    exports: isLib && libsList[libName]?.libMainFile ? `./bin/${path.basename(libsList[libName].libMainFile)}` : `./bin/${config.coreEntryFile}`,
-    homepage: pkgHomepage,
-    license: license || "MIT",
-    name,
-    publish: {
-      exclude: ["!.", "node_modules/**", ".env"]
-    },
-    version
-  };
-  const jsrArtifacts = isLib ? config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr : config.publishArtifacts?.["dist-jsr"] || ["jsr.json"];
-  const jsrConfigExt = jsrArtifacts?.find((artifact) => artifact.startsWith("jsr.json"))?.split(".").pop() || "json";
-  const jsrConfigPath = path.join(outDirRoot, `jsr.${jsrConfigExt}`);
-  await fs.writeJSON(jsrConfigPath, jsrConfig, {
-    spaces: 2
-  });
-  relinka("verbose", `Generated jsr.${jsrConfigExt} file in ${outDirRoot}/jsr.${jsrConfigExt}`);
-}
-export async function renameTsxFiles(dir) {
-  relinka("verbose", `Renaming .tsx files in directory: ${dir}`);
-  const files = await glob(["**/*.tsx"], {
-    absolute: true,
-    cwd: dir
-  });
-  const processedPaths = /* @__PURE__ */ new Set();
-  await pMap(
-    files,
-    async (filePath) => {
-      const newPath = filePath.replace(/\.tsx$/, "-tsx.txt");
-      if (processedPaths.has(newPath)) {
-        throw new Error(`Path conflict detected: ${newPath} would be created multiple times`);
-      }
-      if (await fs.pathExists(newPath)) {
-        throw new Error(`Target file already exists: ${newPath}`);
-      }
-      try {
-        await fs.rename(filePath, newPath);
-        processedPaths.add(newPath);
-        relinka("verbose", `Renamed: ${filePath} -> ${newPath}`);
-        if (await fs.pathExists(filePath)) {
-          throw new Error(`Source file still exists after rename: ${filePath}`);
-        }
-        if (!await fs.pathExists(newPath)) {
-          throw new Error(`Target file not found after rename: ${newPath}`);
-        }
-      } catch (error) {
-        throw new Error(`Failed to rename ${filePath} to ${newPath}: ${error}`);
-      }
-    },
-    { concurrency: CONCURRENCY_DEFAULT }
-  );
-  relinka("verbose", `Completed renaming .tsx files in ${dir}`);
-}

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

@@ -1,7 +0,0 @@
-/**
- * Extracts the package name (or scoped package name) from a potential bare import path.
- * Returns null if the path is relative, absolute, or empty.
- * @param importPath - The import path string.
- * @returns The package name (e.g., "react", "@scope/pkg") or null.
- */
-export declare function extractPackageName(importPath: string | undefined): null | string;

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

@@ -1,7 +0,0 @@
-export function extractPackageName(importPath) {
-  if (!importPath || importPath.startsWith(".") || importPath.startsWith("/")) {
-    return null;
-  }
-  const match = /^(@[^/]+\/[^/]+|[^/]+)/.exec(importPath);
-  return match ? match[0] : null;
-}

package/bin/impl/utils/utils-package-json-libraries.d.ts

@@ -1,10 +0,0 @@
-import type { LibConfig, NpmOutExt, ReliverseConfig } from "../schema/mod.js";
-/**
- * Creates a package.json for a lib distribution.
- */
-export declare function library_createPackageJSON(libName: string, npmOutDir: string, jsrOutDir: string, effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined, libsList: Record<string, LibConfig>, config: ReliverseConfig, unifiedBundlerOutExt: NpmOutExt): Promise<void>;
-/**
- * Creates a JSR configuration file for a library.
- */
-declare function library_createJsrConfig(libName: string, pkgJsonDir: string, libsList: Record<string, LibConfig>, config: ReliverseConfig): Promise<void>;
-export { library_createJsrConfig };

package/bin/impl/utils/utils-package-json-libraries.js

@@ -1,316 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { definePackageJSON, readPackageJSON } from "pkg-types";
-import { filterDeps } from "./utils-deps.js";
-export async function library_createPackageJSON(libName, npmOutDir, jsrOutDir, effectivePubRegistry, libsList, config, unifiedBundlerOutExt) {
-  relinka("verbose", `Creating package.json for library ${libName}`);
-  const originalPkg = await readPackageJSON();
-  const commonPkg = await library_createCommonPackageFields(libName, libsList);
-  if (effectivePubRegistry === "npm" || effectivePubRegistry === "npm-jsr") {
-    await library_writeNpmLibPackageJSON(
-      libName,
-      npmOutDir,
-      npmOutDir,
-      originalPkg,
-      commonPkg,
-      libsList,
-      config,
-      unifiedBundlerOutExt
-    );
-  }
-  if (effectivePubRegistry === "jsr" || effectivePubRegistry === "npm-jsr") {
-    await library_writeJsrPackageJSON(
-      libName,
-      jsrOutDir,
-      jsrOutDir,
-      originalPkg,
-      commonPkg,
-      libsList,
-      config
-    );
-  }
-}
-async function library_createCommonPackageFields(libName, libsList) {
-  relinka("verbose", `Generating common package fields for ${libName}`);
-  const originalPkg = await readPackageJSON();
-  let { description } = originalPkg;
-  const { author, keywords, license, version } = originalPkg;
-  if (libsList?.[libName]?.libDescription) {
-    description = libsList[libName].libDescription;
-    relinka("verbose", `Using ${libName}'s description from config: "${description}"`);
-  } else {
-    description = description || `${libName} is a helper library.`;
-    relinka("verbose", `Using default helper library description: "${description}"`);
-  }
-  const commonPkg = {
-    description,
-    license: license || "MIT",
-    name: libName,
-    type: "module",
-    version
-  };
-  if (author) {
-    const repoOwner = typeof author === "string" ? author : author.name;
-    const repoName = originalPkg.name ? originalPkg.name.startsWith("@") ? originalPkg.name.split("/").pop() || originalPkg.name : originalPkg.name : "";
-    Object.assign(commonPkg, {
-      author,
-      bugs: {
-        email: "blefnk@gmail.com",
-        url: `https://github.com/${repoOwner}/${repoName}/issues`
-      },
-      keywords: [.../* @__PURE__ */ new Set([author, ...keywords || []])],
-      repository: {
-        type: "git",
-        url: `git+https://github.com/${repoOwner}/${repoName}.git`
-      }
-    });
-  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
-    commonPkg.keywords = keywords;
-  }
-  return commonPkg;
-}
-async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr, libConfig, config) {
-  relinka("verbose", `Getting lib dependencies for: ${libName}`);
-  if (!originalDeps) return {};
-  if (!libConfig) {
-    const result2 = await filterDeps(originalDeps, true, outDirBin, isJsr, config, libName);
-    relinka(
-      "verbose",
-      `Lib ${libName} dependencies filtered by usage, count: ${Object.keys(result2).length}`
-    );
-    return result2;
-  }
-  if (libConfig.libPkgKeepDeps === true) {
-    relinka("verbose", `Preserving all dependencies for lib ${libName}`);
-    const originalPkg = await readPackageJSON();
-    const devDeps = originalDeps === originalPkg.devDependencies;
-    const patterns = /* @__PURE__ */ new Set();
-    const addPatterns = /* @__PURE__ */ new Set();
-    const negPatterns = /* @__PURE__ */ new Set();
-    for (const pattern of config.filterDepsPatterns.global) {
-      if (pattern.startsWith("+")) {
-        addPatterns.add(pattern.slice(1));
-      } else if (pattern.startsWith("!")) {
-        negPatterns.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 if (pattern.startsWith("!")) {
-          negPatterns.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 if (pattern.startsWith("!")) {
-          negPatterns.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 if (pattern.startsWith("!")) {
-            negPatterns.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 if (pattern.startsWith("!")) {
-            negPatterns.add(pattern.slice(1));
-          } else {
-            patterns.add(pattern);
-          }
-        }
-      }
-    }
-    const result2 = Object.entries(originalDeps).reduce((acc, [k, v]) => {
-      const depNameLower = k.toLowerCase();
-      const isNegated = Array.from(negPatterns).some(
-        (pattern) => depNameLower.includes(pattern.toLowerCase())
-      );
-      if (isNegated) {
-        acc[k] = v;
-        return acc;
-      }
-      const shouldExclude = devDeps || Array.from(patterns).some((pattern) => depNameLower.includes(pattern.toLowerCase()));
-      if (!shouldExclude) {
-        acc[k] = v;
-      }
-      return acc;
-    }, {});
-    for (const pattern of addPatterns) {
-      if (!result2[pattern] && !originalPkg.dependencies?.[pattern]) {
-        result2[pattern] = originalPkg.devDependencies?.[pattern] || "latest";
-      }
-    }
-    return result2;
-  }
-  if (Array.isArray(libConfig.libPkgKeepDeps)) {
-    relinka(
-      "log",
-      `Including specific dependencies for lib ${libName}: ${libConfig.libPkgKeepDeps.join(", ")}`
-    );
-    const result2 = Object.entries(originalDeps).reduce((acc, [k, v]) => {
-      if (Array.isArray(libConfig.libPkgKeepDeps) && libConfig.libPkgKeepDeps.includes(k)) {
-        acc[k] = v;
-      }
-      return acc;
-    }, {});
-    return result2;
-  }
-  const result = await filterDeps(originalDeps, true, outDirBin, isJsr, config, libName);
-  relinka(
-    "verbose",
-    `Default filtering for lib ${libName} done, count: ${Object.keys(result).length}`
-  );
-  return result;
-}
-async function library_writeJsrPackageJSON(libName, outDirBin, pkgJsonDir, originalPkg, commonPkg, libsList, config) {
-  relinka("verbose", `Writing package.json for JSR lib: ${libName}`);
-  if (!libsList) {
-    throw new Error("libsList is empty or not provided");
-  }
-  if (!libsList[libName]?.libMainFile) {
-    throw new Error(`libsList.${libName}.libMainFile is not defined for library ${libName}`);
-  }
-  const binEntry = commonPkg.bin;
-  if (binEntry) {
-    relinka("verbose", `Found bin entry in commonPkg: ${JSON.stringify(binEntry)}`);
-    const updatedBin = {};
-    for (const [key, value] of Object.entries(binEntry)) {
-      updatedBin[key] = value.replace(/\.js$/, ".ts");
-    }
-    commonPkg.bin = updatedBin;
-    relinka("verbose", `Updated bin entry for JSR: ${JSON.stringify(updatedBin)}`);
-  }
-  const jsrPkg = definePackageJSON({
-    ...commonPkg,
-    dependencies: await library_getlibPkgKeepDeps(
-      libName,
-      originalPkg.dependencies,
-      outDirBin,
-      true,
-      libsList?.[libName] ?? {
-        libDeclarations: false,
-        libDescription: "",
-        libDirName: libName,
-        libMainFile: libsList[libName].libMainFile,
-        libPkgKeepDeps: false,
-        libTranspileMinify: true
-      },
-      config
-    ),
-    devDependencies: await filterDeps(
-      originalPkg.devDependencies,
-      true,
-      outDirBin,
-      true,
-      config,
-      libName
-    ),
-    exports: {
-      ".": `./bin/${path.basename(libsList[libName].libMainFile)}`
-    },
-    files: [
-      .../* @__PURE__ */ new Set([
-        "bin",
-        ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-      ])
-    ],
-    main: `./bin/${path.basename(libsList[libName].libMainFile)}`,
-    module: `./bin/${path.basename(libsList[libName].libMainFile)}`
-  });
-  const pkgPath = path.join(pkgJsonDir, "package.json");
-  await fs.ensureDir(path.dirname(pkgPath));
-  await fs.writeJson(pkgPath, jsrPkg, { spaces: 2 });
-  relinka("verbose", `Completed writing package.json for JSR lib: ${libName}`);
-}
-async function library_writeNpmLibPackageJSON(libName, outDirBin, pkgJsonDir, originalPkg, commonPkg, libsList, config, unifiedBundlerOutExt) {
-  relinka("verbose", `Writing package.json for NPM lib: ${libName}`);
-  if (!libsList) {
-    throw new Error("libsList is empty or not provided");
-  }
-  if (!libsList[libName]?.libMainFile) {
-    throw new Error(`libsList.${libName}.libMainFile is not defined for library ${libName}`);
-  }
-  const npmPkg = definePackageJSON({
-    ...commonPkg,
-    dependencies: await library_getlibPkgKeepDeps(
-      libName,
-      originalPkg.dependencies,
-      outDirBin,
-      false,
-      libsList?.[libName] ?? {
-        libDeclarations: true,
-        libDescription: "",
-        libDirName: libName,
-        libMainFile: libsList[libName].libMainFile,
-        libPkgKeepDeps: true,
-        libTranspileMinify: true
-      },
-      config
-    ),
-    devDependencies: await filterDeps(
-      originalPkg.devDependencies,
-      true,
-      outDirBin,
-      false,
-      config,
-      libName
-    ),
-    exports: {
-      ".": `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`
-    },
-    files: [
-      .../* @__PURE__ */ new Set([
-        "bin",
-        ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-      ])
-    ],
-    main: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
-    module: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
-    publishConfig: { access: "public" }
-  });
-  const pkgPath = path.join(pkgJsonDir, "package.json");
-  await fs.ensureDir(path.dirname(pkgPath));
-  await fs.writeJson(pkgPath, npmPkg, { spaces: 2 });
-  relinka("verbose", `Completed writing package.json for NPM lib: ${libName}`);
-}
-async function library_createJsrConfig(libName, pkgJsonDir, libsList, config) {
-  relinka("verbose", `Creating JSR config for lib: ${libName}`);
-  const jsrArtifacts = config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr || config.publishArtifacts?.["dist-jsr"] || ["jsr.json"];
-  const jsrConfigExt = jsrArtifacts.find((artifact) => artifact.startsWith("jsr.json"))?.split(".").pop() || "json";
-  const jsrConfigPath = path.join(pkgJsonDir, `jsr.${jsrConfigExt}`);
-  const originalPkg = await readPackageJSON();
-  const jsrConfig = {
-    name: libName,
-    version: libsList[libName]?.version || originalPkg.version || "0.0.0",
-    exports: `./bin/${path.basename(libsList[libName]?.libMainFile || "")}`,
-    files: config.publishArtifacts?.global || ["bin", "package.json", "README.md", "LICENSE"]
-  };
-  await fs.ensureDir(path.dirname(jsrConfigPath));
-  await fs.writeJson(jsrConfigPath, jsrConfig, { spaces: 2 });
-  relinka("verbose", `Completed creating JSR config for lib: ${libName}`);
-}
-export { library_createJsrConfig };