@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/utils.js

@@ -0,0 +1,158 @@
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import { readdirSync, statSync } from "node:fs";
+import fsp from "node:fs/promises";
+import { dirname, resolve } from "pathe";
+import { autoPreset } from "./auto.js";
+export function arrayIncludes(arr, searchElement) {
+  return arr.some(
+    (entry) => entry instanceof RegExp ? entry.test(searchElement) : entry === searchElement
+  );
+}
+export function dumpObject(obj) {
+  return `{ ${Object.keys(obj).map((key) => `${key}: ${JSON.stringify(obj[key])}`).join(", ")} }`;
+}
+export async function ensuredir(path) {
+  await fsp.mkdir(dirname(path), { recursive: true });
+}
+export function extractExportFilenames(exports, conditions = []) {
+  if (!exports) {
+    return [];
+  }
+  if (typeof exports === "string") {
+    return [{ file: exports, type: "esm" }];
+  }
+  return Object.entries(exports).filter(([subpath]) => !subpath.endsWith(".json")).flatMap(
+    ([condition, exports2]) => typeof exports2 === "string" ? {
+      file: exports2,
+      type: inferExportType(condition, conditions, exports2)
+    } : extractExportFilenames(exports2, [...conditions, condition])
+  );
+}
+export function getpkg(id = "") {
+  const s = id.split("/");
+  return s[0]?.startsWith("@") ? `${s[0]}/${s[1] || ""}` : s[0] || "";
+}
+export function inferPkgExternals(pkg) {
+  const externals = [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}).filter(
+      (dep) => dep.startsWith("@types/")
+    ),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ];
+  if (pkg.name) {
+    externals.push(pkg.name);
+    if (pkg.exports) {
+      for (const subpath of Object.keys(pkg.exports)) {
+        if (subpath.startsWith("./")) {
+          externals.push(pathToRegex(`${pkg.name}/${subpath.slice(2)}`));
+        }
+      }
+    }
+  }
+  if (pkg.imports) {
+    for (const importName of Object.keys(pkg.imports)) {
+      if (importName.startsWith("#")) {
+        externals.push(pathToRegex(importName));
+      }
+    }
+  }
+  return [...new Set(externals)];
+}
+export function listRecursively(path) {
+  const filenames = /* @__PURE__ */ new Set();
+  const walk = (path2) => {
+    const files = readdirSync(path2);
+    for (const file of files) {
+      const fullPath = resolve(path2, file);
+      if (statSync(fullPath).isDirectory()) {
+        filenames.add(`${fullPath}/`);
+        walk(fullPath);
+      } else {
+        filenames.add(fullPath);
+      }
+    }
+  };
+  walk(path);
+  return [...filenames];
+}
+export function removeExtension(filename) {
+  return filename.replace(/\.(js|mjs|cjs|ts|mts|cts|json|jsx|tsx)$/, "");
+}
+export async function resolvePreset(preset, rootDir) {
+  let resolvedPreset = preset;
+  if (preset === "auto") {
+    resolvedPreset = autoPreset;
+  } else if (typeof preset === "string") {
+    resolvedPreset = await createJiti(rootDir, { interopDefault: true }).import(preset, {
+      default: true
+    }) || {};
+  }
+  if (typeof resolvedPreset === "function") {
+    resolvedPreset = resolvedPreset();
+  }
+  return resolvedPreset;
+}
+export async function rmdir(dir) {
+  await fsp.unlink(dir).catch(() => {
+  });
+  await fsp.rm(dir, { force: true, recursive: true }).catch(() => {
+  });
+}
+export async function symlink(from, to, force = true) {
+  await ensuredir(to);
+  if (force) {
+    await fsp.unlink(to).catch(() => {
+    });
+  }
+  await fsp.symlink(from, to, "junction");
+}
+export function warn(ctx, message) {
+  if (ctx.warnings.has(message)) {
+    return;
+  }
+  relinka("verbose", "[dler] [warn]", message);
+  ctx.warnings.add(message);
+}
+export function withTrailingSlash(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+function inferExportType(condition, previousConditions = [], filename = "") {
+  if (filename) {
+    if (filename.endsWith(".d.ts")) {
+      return "esm";
+    }
+    if (filename.endsWith(".mjs")) {
+      return "esm";
+    }
+    if (filename.endsWith(".cjs")) {
+      return "cjs";
+    }
+  }
+  switch (condition) {
+    case "import": {
+      return "esm";
+    }
+    case "require": {
+      return "cjs";
+    }
+    default: {
+      if (previousConditions.length === 0) {
+        return "esm";
+      }
+      const [newCondition] = previousConditions;
+      return inferExportType(
+        newCondition || "import",
+        previousConditions.slice(1),
+        filename
+      );
+    }
+  }
+}
+function pathToRegex(path) {
+  return path.includes("*") ? new RegExp(
+    `^${path.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`
+  ) : path;
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/validate.js

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { resolve } from "pathe";
+import {
+  arrayIncludes,
+  extractExportFilenames,
+  getpkg,
+  warn
+} from "./utils.js";
+export function validateDependencies(ctx) {
+  const usedDependencies = /* @__PURE__ */ new Set();
+  const unusedDependencies = new Set(
+    Object.keys(ctx.pkg.dependencies || {})
+  );
+  const implicitDependencies = /* @__PURE__ */ new Set();
+  for (const id of ctx.usedImports) {
+    unusedDependencies.delete(id);
+    usedDependencies.add(id);
+  }
+  if (Array.isArray(ctx.options.dependencies)) {
+    for (const id of ctx.options.dependencies) {
+      unusedDependencies.delete(id);
+    }
+  }
+  for (const id of usedDependencies) {
+    if (!arrayIncludes(ctx.options.externals, id) && !id.startsWith("chunks/") && !ctx.options.dependencies.includes(getpkg(id)) && !ctx.options.peerDependencies.includes(getpkg(id))) {
+      implicitDependencies.add(id);
+    }
+  }
+  if (unusedDependencies.size > 0) {
+    warn(
+      ctx,
+      `Potential unused dependencies found: ${[...unusedDependencies].join(", ")}`
+    );
+  }
+  if (implicitDependencies.size > 0 && !ctx.options.rollup.inlineDependencies) {
+    warn(
+      ctx,
+      `Potential implicit dependencies found: ${[...implicitDependencies].join(", ")}`
+    );
+  }
+}
+export function validatePackage(pkg, rootDir, ctx) {
+  if (!pkg) {
+    return;
+  }
+  const filenames = new Set(
+    [
+      ...typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin || {}),
+      pkg.main,
+      pkg.module,
+      pkg.types,
+      pkg.typings,
+      ...extractExportFilenames(pkg.exports).map((i) => i.file)
+    ].map((i) => i && resolve(rootDir, i.replace(/\/[^/]*\*.*$/, "")))
+  );
+  const missingOutputs = [];
+  for (const filename of filenames) {
+    if (filename && !filename.includes("*") && !existsSync(filename)) {
+      missingOutputs.push(filename.replace(`${rootDir}/`, ""));
+    }
+  }
+  if (missingOutputs.length > 0) {
+    warn(
+      ctx,
+      `Potential missing package.json files: ${missingOutputs.join(", ")}`
+    );
+  }
+}

package/bin/libs/sdk/sdk-impl/library-flow.js

@@ -0,0 +1,169 @@
+import { relinka } from "@reliverse/relinka";
+import pAll from "p-all";
+import path from "pathe";
+import { library_buildLibrary } from "./build/build-library.js";
+import { library_publishLibrary } from "./pub/pub-library.js";
+import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "./utils/utils-consts.js";
+export async function processLibraryFlow(timer, isDev, libsActMode, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, libsDirSrc, commonPubPause, commonPubRegistry, unifiedBundlerOutExt, distNpmBuilder, coreEntrySrcDir, rmDepsMode, rmDepsPatterns, transpileEsbuild, transpileTarget, transpileFormat, transpileSplitting, transpileSourcemap, transpilePublicPath, distJsrBuilder, transpileStub, transpileWatch, distJsrOutFilesExt) {
+  if (libsActMode !== "libs-only" && libsActMode !== "main-and-libs") {
+    relinka(
+      "verbose",
+      "Skipping libs build/publish as libsActMode is set to 'main-project-only'"
+    );
+    return;
+  }
+  await libraries_buildPublish(
+    isDev,
+    timer,
+    libsList,
+    distJsrDryRun,
+    distJsrFailOnWarn,
+    libsDirDist,
+    libsDirSrc,
+    commonPubPause,
+    commonPubRegistry,
+    unifiedBundlerOutExt,
+    distNpmBuilder,
+    coreEntrySrcDir,
+    rmDepsMode,
+    rmDepsPatterns,
+    transpileEsbuild,
+    transpileTarget,
+    transpileFormat,
+    transpileSplitting,
+    transpileSourcemap,
+    transpilePublicPath,
+    distJsrBuilder,
+    transpileStub,
+    transpileWatch,
+    distJsrOutFilesExt
+  );
+}
+function extractFolderName(libName, libConfig) {
+  if (libConfig?.libDirName) {
+    return libConfig.libDirName;
+  }
+  const parts = libName.split("/");
+  let baseName = parts[parts.length - 1];
+  if (baseName?.includes("-")) {
+    const dashParts = baseName.split("-");
+    baseName = dashParts[dashParts.length - 1];
+  }
+  if (!baseName) {
+    baseName = libName;
+  }
+  return baseName;
+}
+export async function libraries_buildPublish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, libsDirSrc, commonPubPause, commonPubRegistry, unifiedBundlerOutExt, distNpmBuilder, coreEntrySrcDir, rmDepsMode, rmDepsPatterns, transpileEsbuild, transpileTarget, transpileFormat, transpileSplitting, transpileSourcemap, transpilePublicPath, distJsrBuilder, transpileStub, transpileWatch, distJsrOutFilesExt) {
+  relinka("verbose", "Starting libraries_buildPublish");
+  if (!libsList || Object.keys(libsList).length === 0) {
+    relinka("info", "No lib configs found in config, skipping libs build.");
+    return;
+  }
+  const libsEntries = Object.entries(libsList);
+  const tasks = libsEntries.map(([libName, libConfig]) => {
+    return async () => {
+      try {
+        if (!libConfig.libMainFile) {
+          throw new Error(
+            `Library ${libName} is missing "libMainFile" property.`
+          );
+        }
+        const folderName = extractFolderName(libName, libConfig);
+        const libBaseDir = path.resolve(PROJECT_ROOT, libsDirDist, folderName);
+        const npmOutDir = path.join(libBaseDir, "npm");
+        const jsrOutDir = path.join(libBaseDir, "jsr");
+        const libMainPath = path.parse(libConfig.libMainFile);
+        const libMainFile = libMainPath.base;
+        let libMainDir;
+        if (libConfig.libMainFile.startsWith(libsDirSrc)) {
+          libMainDir = libMainPath.dir || ".";
+        } else if (libMainPath.dir) {
+          libMainDir = path.join(libsDirSrc, libMainPath.dir);
+        } else {
+          libMainDir = path.join(libsDirSrc, folderName);
+        }
+        relinka(
+          "verbose",
+          `Processing library ${libName}: libMainDir=${libMainDir}, libMainFile=${libMainFile}`
+        );
+        const libTranspileMinify = libConfig?.libTranspileMinify === true;
+        await library_buildLibrary({
+          commonPubRegistry,
+          libName,
+          mainDir: libMainDir,
+          npm: {
+            npmOutDir,
+            distNpmBuilder,
+            coreEntrySrcDir
+          },
+          jsr: {
+            jsrOutDir,
+            distJsrBuilder,
+            distJsrOutFilesExt
+          },
+          libMainFile,
+          isDev,
+          libsList,
+          unifiedBundlerOutExt,
+          rmDepsMode,
+          rmDepsPatterns,
+          transpileEsbuild,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          libTranspileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          timer,
+          transpileStub,
+          transpileWatch
+        });
+        if (!commonPubPause) {
+          await library_publishLibrary(
+            commonPubRegistry,
+            libName,
+            npmOutDir,
+            jsrOutDir,
+            distJsrDryRun,
+            distJsrFailOnWarn,
+            false,
+            false,
+            isDev,
+            timer
+          );
+        }
+      } catch (error) {
+        relinka(
+          "error",
+          `Failed to process library ${libName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        if (isDev && error instanceof Error) {
+          relinka("verbose", `Error details: ${error.stack}`);
+        }
+        throw error;
+      }
+    };
+  });
+  try {
+    await pAll(tasks, {
+      concurrency: CONCURRENCY_DEFAULT
+    });
+    relinka("verbose", "Completed libraries_buildPublish");
+  } catch (error) {
+    if (error instanceof AggregateError) {
+      for (const individualError of error.errors) {
+        relinka(
+          "error",
+          `AggregateError: ${individualError instanceof Error ? individualError.message : String(individualError)}`
+        );
+      }
+    } else {
+      relinka(
+        "error",
+        `Unhandled error in libraries_buildPublish: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    throw error;
+  }
+}

package/bin/libs/sdk/sdk-impl/pub/pub-library.js

@@ -0,0 +1,132 @@
+import { relinka } from "@reliverse/relinka";
+import { execaCommand } from "execa";
+import pAll from "p-all";
+import { CONCURRENCY_DEFAULT } from "../utils/utils-consts.js";
+import { withWorkingDirectory } from "../utils/utils-cwd.js";
+import {
+  pausePerfTimer,
+  resumePerfTimer
+} from "../utils/utils-perf.js";
+export async function library_publishLibrary(commonPubRegistry, libName, npmOutDir, jsrOutDir, distJsrDryRun, distJsrFailOnWarn, distJsrAllowDirty, distJsrSlowTypes, isDev, timer) {
+  if (isDev) {
+    relinka(
+      "info",
+      `Skipping publishing for lib ${libName} in development mode`
+    );
+    return;
+  }
+  switch (commonPubRegistry) {
+    case "jsr":
+      relinka("info", `Publishing lib ${libName} to JSR only...`);
+      await library_pubToJsr(
+        jsrOutDir,
+        distJsrDryRun,
+        distJsrFailOnWarn,
+        distJsrAllowDirty,
+        distJsrSlowTypes,
+        libName,
+        isDev,
+        timer
+      );
+      break;
+    case "npm":
+      relinka("info", `Publishing lib ${libName} to NPM only...`);
+      await library_pubToNpm(
+        npmOutDir,
+        distJsrDryRun,
+        distJsrFailOnWarn,
+        libName,
+        isDev,
+        timer
+      );
+      break;
+    case "npm-jsr": {
+      relinka("info", `Publishing lib ${libName} to both NPM and JSR...`);
+      const publishTasks = [
+        () => library_pubToNpm(
+          npmOutDir,
+          distJsrDryRun,
+          distJsrFailOnWarn,
+          libName,
+          isDev,
+          timer
+        ),
+        () => library_pubToJsr(
+          jsrOutDir,
+          distJsrDryRun,
+          distJsrFailOnWarn,
+          distJsrAllowDirty,
+          distJsrSlowTypes,
+          libName,
+          isDev,
+          timer
+        )
+      ];
+      await pAll(publishTasks, { concurrency: CONCURRENCY_DEFAULT });
+      break;
+    }
+    default:
+      relinka(
+        "info",
+        `Registry "${commonPubRegistry}" not recognized for lib ${libName}. Skipping publishing for this lib.`
+      );
+  }
+}
+async function library_pubToJsr(libOutDir, distJsrDryRun, distJsrFailOnWarn, distJsrAllowDirty, distJsrSlowTypes, libName, isDev, timer) {
+  relinka("verbose", `Starting library_pubToJsr for lib: ${libName}`);
+  if (isDev) {
+    relinka("info", `Skipping lib ${libName} JSR publish in development mode`);
+    return;
+  }
+  try {
+    if (timer) pausePerfTimer(timer);
+    await withWorkingDirectory(libOutDir, async () => {
+      relinka("info", `Publishing lib ${libName} to JSR from ${libOutDir}`);
+      const command = [
+        "bun x jsr publish",
+        distJsrDryRun ? "--dry-run" : "",
+        distJsrFailOnWarn ? "--fail-on-warn" : "",
+        distJsrAllowDirty ? "--allow-dirty" : "",
+        distJsrSlowTypes ? "--allow-slow-types" : ""
+      ].filter(Boolean).join(" ");
+      await execaCommand(command, { stdio: "inherit" });
+      relinka(
+        "success",
+        `Successfully ${distJsrDryRun ? "validated" : "published"} lib ${libName} to JSR registry`
+      );
+    });
+    if (timer) resumePerfTimer(timer);
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    relinka("error", `Failed to publish lib ${libName} to JSR`, error);
+    throw error;
+  } finally {
+    relinka("verbose", `Exiting library_pubToJsr for lib: ${libName}`);
+  }
+}
+async function library_pubToNpm(libOutDir, distJsrDryRun, distJsrFailOnWarn, libName, isDev, timer) {
+  relinka("verbose", `Starting library_pubToNpm for lib: ${libName}`);
+  if (isDev) {
+    relinka("info", `Skipping lib ${libName} NPM publish in development mode`);
+    return;
+  }
+  try {
+    if (timer) pausePerfTimer(timer);
+    await withWorkingDirectory(libOutDir, async () => {
+      relinka("info", `Publishing lib ${libName} to NPM from ${libOutDir}`);
+      const command = ["bun publish", distJsrDryRun ? "--dry-run" : ""].filter(Boolean).join(" ");
+      await execaCommand(command, { stdio: "inherit" });
+      relinka(
+        "success",
+        `Successfully ${distJsrDryRun ? "validated" : "published"} lib ${libName} to NPM registry`
+      );
+    });
+    if (timer) resumePerfTimer(timer);
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    relinka("error", `Failed to publish lib ${libName} to NPM`, error);
+    throw error;
+  } finally {
+    relinka("verbose", `Exiting library_pubToNpm for lib: ${libName}`);
+  }
+}

package/bin/libs/sdk/sdk-impl/pub/pub-regular.js

@@ -0,0 +1,69 @@
+import { relinka } from "@reliverse/relinka";
+import { execaCommand } from "execa";
+import path from "pathe";
+import { PROJECT_ROOT } from "../utils/utils-consts.js";
+import { withWorkingDirectory } from "../utils/utils-cwd.js";
+import {
+  pausePerfTimer,
+  resumePerfTimer
+} from "../utils/utils-perf.js";
+export async function regular_pubToJsr(distJsrDryRun, distJsrFailOnWarn, isDev, commonPubPause, distJsrDirName, distJsrAllowDirty, distJsrSlowTypes, timer) {
+  try {
+    if (isDev) {
+      relinka("info", "Skipping JSR publish in development mode");
+      return;
+    }
+    if (!commonPubPause) {
+      relinka("info", "Publishing to JSR...");
+      const distJsrDirNameResolved = path.resolve(PROJECT_ROOT, distJsrDirName);
+      if (timer) pausePerfTimer(timer);
+      await withWorkingDirectory(distJsrDirNameResolved, async () => {
+        const command = [
+          "bun x jsr publish",
+          distJsrDryRun ? "--dry-run" : "",
+          distJsrFailOnWarn ? "--fail-on-warn" : "",
+          distJsrAllowDirty ? "--allow-dirty" : "",
+          distJsrSlowTypes ? "--allow-slow-types" : ""
+        ].filter(Boolean).join(" ");
+        relinka("verbose", `Running publish command: ${command}`);
+        await execaCommand(command, { stdio: "inherit" });
+        relinka(
+          "success",
+          `Successfully ${distJsrDryRun ? "validated" : "published"} to JSR registry`
+        );
+      });
+      if (timer) resumePerfTimer(timer);
+    }
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    relinka("error", "Failed to publish to JSR:", error);
+    throw error;
+  }
+}
+export async function regular_pubToNpm(distJsrDryRun, isDev, commonPubPause, distNpmDirName, timer) {
+  try {
+    if (isDev) {
+      relinka("info", "Skipping NPM publish in development mode");
+      return;
+    }
+    if (!commonPubPause) {
+      relinka("info", "Publishing to NPM...");
+      const distNpmDirNameResolved = path.resolve(PROJECT_ROOT, distNpmDirName);
+      if (timer) pausePerfTimer(timer);
+      await withWorkingDirectory(distNpmDirNameResolved, async () => {
+        const command = ["bun publish", distJsrDryRun ? "--dry-run" : ""].filter(Boolean).join(" ");
+        relinka("verbose", `Running publish command: ${command}`);
+        await execaCommand(command, { stdio: "inherit" });
+        relinka(
+          "success",
+          `Successfully ${distJsrDryRun ? "validated" : "published"} to NPM registry`
+        );
+      });
+      if (timer) resumePerfTimer(timer);
+    }
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    relinka("error", "Failed to publish to NPM:", error);
+    throw error;
+  }
+}