@reliverse/dler 1.2.0

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

@@ -0,0 +1,73 @@
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON } from "pkg-types";
+import { glob } from "tinyglobby";
+import { readFileSafe } from "./utils-fs.js";
+import { extractPackageName } from "./utils-paths.js";
+export async function filterDeps(deps, clearUnused, outDirBin, isJsr, rmDepsMode, rmDepsPatterns) {
+  relinka("verbose", `Filtering dependencies (clearUnused=${clearUnused})`);
+  if (!deps) return {};
+  const shouldExcludeByPattern = (depName) => {
+    return rmDepsPatterns.some(
+      (pattern) => depName.toLowerCase().includes(pattern.toLowerCase())
+    );
+  };
+  const originalPkg = await readPackageJSON();
+  const shouldExcludeDep = (depName, isDev) => {
+    if (rmDepsMode === "patterns-only") {
+      return shouldExcludeByPattern(depName);
+    }
+    if (rmDepsMode === "patterns-and-devdeps") {
+      return isDev || shouldExcludeByPattern(depName);
+    }
+    return 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;
+      },
+      {}
+    );
+    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/libs/sdk/sdk-impl/utils/utils-determine.js

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

@@ -0,0 +1,17 @@
+import { relinka } from "@reliverse/relinka";
+import prettyMilliseconds from "pretty-ms";
+import { getElapsedPerfTime } from "./utils-perf.js";
+export function handleDlerError(error, timer) {
+  const elapsedTime = getElapsedPerfTime(timer);
+  const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
+    verbose: true
+  });
+  const errorStack = error instanceof Error ? error.stack : "No stack trace available";
+  relinka(
+    "error",
+    `An unexpected error occurred after ${transpileFormattedTime}:`,
+    error
+  );
+  relinka("verbose", `Error details: ${errorStack}`);
+  process.exit(1);
+}

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

@@ -0,0 +1,202 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+import { glob } from "tinyglobby";
+import { CONCURRENCY_DEFAULT, SHOW_VERBOSE } from "./utils-consts.js";
+import { determineDistName } from "./utils-determine.js";
+export async function copyRootFile(outDirRoot, fileNames) {
+  if (fileNames.length === 0) {
+    return;
+  }
+  try {
+    await fs.ensureDir(outDirRoot);
+    const specialFileHandlers = {
+      LICENSE: {
+        outputName: "LICENSE",
+        variants: ["LICENSE", "LICENSE.md"]
+      },
+      "README.md": {}
+    };
+    await pMap(
+      fileNames,
+      async (fileName) => {
+        try {
+          const specialConfig = specialFileHandlers[fileName];
+          if (specialConfig?.variants) {
+            for (const variant of specialConfig.variants) {
+              const file = await findFileCaseInsensitive(variant);
+              if (file) {
+                const outputName = specialConfig.outputName || fileName;
+                await fs.copy(file, path.join(outDirRoot, outputName));
+                relinka(
+                  "verbose",
+                  `Copied ${file} to ${outDirRoot}/${outputName}`
+                );
+                break;
+              }
+            }
+          } else {
+            const file = await findFileCaseInsensitive(fileName);
+            if (file) {
+              await fs.copy(file, path.join(outDirRoot, fileName));
+              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;
+  }
+  async function traverse(dir) {
+    const entries = await fs.readdir(dir);
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry);
+      const stats = await fs.stat(fullPath);
+      if (stats.isDirectory()) {
+        await traverse(fullPath);
+      } else if (stats.isFile()) {
+        fileCount++;
+      }
+    }
+  }
+  await traverse(outDirBin);
+  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(
+      "info",
+      `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;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { relinka } from "@reliverse/relinka";
+import prettyMilliseconds from "pretty-ms";
+import { setBumpDisabled } from "./utils-bump.js";
+import { removeDistFolders } from "./utils-clean.js";
+import { getElapsedPerfTime } from "./utils-perf.js";
+export async function finalizeBuild(timer, commonPubPause, libsList, distNpmDirName, distJsrDirName, libsDirDist, isDev) {
+  if (!commonPubPause) {
+    await removeDistFolders(
+      distNpmDirName,
+      distJsrDirName,
+      libsDirDist,
+      libsList
+    );
+    await setBumpDisabled(false, commonPubPause);
+  }
+  const elapsedTime = getElapsedPerfTime(timer);
+  const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
+    verbose: true
+  });
+  if (!commonPubPause) {
+    relinka(
+      "success",
+      `\u{1F389} Build and publishing completed successfully (in ${transpileFormattedTime})`
+    );
+  } else {
+    relinka(
+      "success",
+      `\u{1F389} Test build completed successfully (in ${transpileFormattedTime})`
+    );
+    if (!isDev) {
+      relinka(
+        "info",
+        "\u{1F4DD} Publish process is currently paused in your config file"
+      );
+    } else {
+      relinka(
+        "info",
+        "\u{1F4DD} Publish is paused, you're in dev mode (use `bun pub` to publish)"
+      );
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+import { readPackageJSON } from "pkg-types";
+import { glob } from "tinyglobby";
+import { cliDomainDocs, CONCURRENCY_DEFAULT } from "./utils-consts.js";
+export async function createJsrJSON(outDirRoot, isLib, libName = "unknown-lib-name", libDescription = "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 = libDescription;
+  }
+  const pkgHomepage = cliDomainDocs;
+  const jsrConfig = {
+    author,
+    description,
+    exports: "./bin/main.ts",
+    homepage: pkgHomepage,
+    license: license || "MIT",
+    name,
+    publish: {
+      exclude: ["!.", "node_modules/**", ".env"]
+    },
+    version
+  };
+  await fs.writeJSON(path.join(outDirRoot, "jsr.json"), jsrConfig, {
+    spaces: 2
+  });
+  relinka("verbose", `Generated jsr.json file in ${outDirRoot}/jsr.json`);
+}
+export async function renameTsxFiles(dir) {
+  relinka("verbose", `Renaming .tsx files in directory: ${dir}`);
+  const files = await glob(["**/*.tsx"], {
+    absolute: true,
+    cwd: dir
+  });
+  await pMap(
+    files,
+    async (filePath) => {
+      const newPath = filePath.replace(/\.tsx$/, "-tsx.txt");
+      await fs.rename(filePath, newPath);
+      relinka("verbose", `Renamed: ${filePath} -> ${newPath}`);
+    },
+    { concurrency: CONCURRENCY_DEFAULT }
+  );
+  relinka("verbose", `Completed renaming .tsx files in ${dir}`);
+}