@reliverse/dler 1.2.0

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

@@ -0,0 +1,373 @@
+import { relinka } from "@reliverse/relinka";
+import { build as bunBuild } from "bun";
+import fs from "fs-extra";
+import path from "pathe";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+import { build as unifiedBuild } from "./bundlers/unified/build.js";
+import {
+  getBunSourcemapOption,
+  getUnifiedSourcemapOption
+} from "../utils/utils-build.js";
+import {
+  CONCURRENCY_DEFAULT,
+  PROJECT_ROOT,
+  validExtensions
+} from "../utils/utils-consts.js";
+import {
+  copyRootFile,
+  deleteSpecificFiles,
+  getDirectorySize,
+  outDirBinFilesCount
+} from "../utils/utils-fs.js";
+import {
+  createJsrJSON,
+  renameTsxFiles
+} from "../utils/utils-jsr-json.js";
+import {
+  convertImportExtensionsJsToTs,
+  convertImportPaths
+} from "../utils/utils-paths.js";
+import {
+  getElapsedPerfTime
+} from "../utils/utils-perf.js";
+import { regular_createPackageJSON } from "../utils/utils-pkg-json-reg.js";
+import { createTSConfig } from "../utils/utils-tsconfig.js";
+import { ensuredir } from "./bundlers/unified/utils.js";
+export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrcDir, distJsrDirName, distJsrBuilder, coreEntryFile, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, unifiedBundlerOutExt, rmDepsMode, timer, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations) {
+  relinka("info", "Building JSR distribution...");
+  const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
+  const coreEntryFilePath = path.join(coreEntrySrcDirResolved, coreEntryFile);
+  const distJsrDirNameResolved = path.resolve(PROJECT_ROOT, distJsrDirName);
+  const outDirBin = path.resolve(distJsrDirNameResolved, "bin");
+  await ensuredir(distJsrDirNameResolved);
+  await ensuredir(outDirBin);
+  relinka("info", `Using JSR builder: ${distJsrBuilder}`);
+  await regular_bundleWithBuilder(distJsrBuilder, {
+    coreDeclarations,
+    outDir: outDirBin,
+    packageName: "",
+    // not strictly needed, keeping it for logs
+    singleFile: coreEntryFilePath,
+    // single entry (used if "bun"/"unified")
+    srcDir: coreEntrySrcDirResolved,
+    // entire dir (used if "jsr")
+    timer,
+    transpileFormat,
+    transpileMinify,
+    transpilePublicPath,
+    transpileSourcemap,
+    transpileSplitting,
+    transpileStub,
+    transpileTarget,
+    transpileWatch,
+    unifiedBundlerOutExt
+  });
+  await regular_performCommonBuildSteps({
+    coreIsCLI,
+    isJsr,
+    outDirBin,
+    outDirRoot: distJsrDirNameResolved,
+    rmDepsMode,
+    unifiedBundlerOutExt
+  });
+  await convertImportExtensionsJsToTs({ dirPath: outDirBin });
+  await renameTsxFiles(outDirBin);
+  await createJsrJSON(distJsrDirNameResolved, false);
+  if (coreIsCLI && isJsr && distJsrGenTsconfig) {
+    await createTSConfig(distJsrDirNameResolved, true);
+  }
+  const dirSize = await getDirectorySize(distJsrDirNameResolved, isDev);
+  const filesCount = await outDirBinFilesCount(outDirBin);
+  relinka(
+    "success",
+    `[${distJsrDirNameResolved}] Successfully created regular distribution: "dist-jsr" (${outDirBin}/main.ts) with (${filesCount} files (${prettyBytes(
+      dirSize
+    )}))`
+  );
+}
+export async function regular_buildNpmDist(isDev, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, unifiedBundlerOutExt, rmDepsMode, coreIsCLI, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, transpileStub, transpileWatch, timer, coreDeclarations) {
+  relinka("info", "Building NPM distribution...");
+  const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
+  const coreEntryFilePath = path.join(coreEntrySrcDirResolved, coreEntryFile);
+  const distNpmDirNameResolved = path.resolve(PROJECT_ROOT, distNpmDirName);
+  const outDirBin = path.resolve(distNpmDirNameResolved, "bin");
+  await ensuredir(distNpmDirNameResolved);
+  await ensuredir(outDirBin);
+  relinka("info", `Using NPM builder: ${distNpmBuilder}`);
+  await regular_bundleWithBuilder(distNpmBuilder, {
+    coreDeclarations,
+    outDir: outDirBin,
+    packageName: "",
+    // For logging
+    singleFile: coreEntryFilePath,
+    srcDir: coreEntrySrcDirResolved,
+    timer,
+    transpileFormat,
+    transpileMinify,
+    transpilePublicPath,
+    transpileSourcemap,
+    transpileSplitting,
+    transpileStub,
+    transpileTarget,
+    transpileWatch,
+    unifiedBundlerOutExt
+  });
+  await regular_performCommonBuildSteps({
+    coreIsCLI,
+    isJsr: false,
+    outDirBin,
+    outDirRoot: distNpmDirNameResolved,
+    rmDepsMode,
+    unifiedBundlerOutExt
+  });
+  const dirSize = await getDirectorySize(distNpmDirNameResolved, isDev);
+  const filesCount = await outDirBinFilesCount(outDirBin);
+  relinka(
+    "success",
+    `NPM distribution built successfully (${filesCount} files, ${prettyBytes(dirSize)})`
+  );
+  relinka(
+    "success",
+    `[${distNpmDirNameResolved}] Successfully created regular distribution: "dist-npm" (${outDirBin}/main.js) with (${filesCount} files (${prettyBytes(
+      dirSize
+    )}))`
+  );
+}
+async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, timer) {
+  relinka(
+    "verbose",
+    `Bundling regular project using Bun (entry: ${coreEntryFile}, outDir: ${outDirBin})`
+  );
+  if (!await fs.pathExists(coreEntryFile)) {
+    relinka("error", `Could not find entry file at: ${coreEntryFile}`);
+    throw new Error(`Entry file not found: ${coreEntryFile}`);
+  }
+  try {
+    const buildResult = await bunBuild({
+      banner: "/* Bundled by @reliverse/dler */",
+      define: {
+        "process.env.NODE_ENV": JSON.stringify(
+          process.env.NODE_ENV || "production"
+        )
+      },
+      drop: ["debugger"],
+      entrypoints: [coreEntryFile],
+      footer: "/* End of bundle */",
+      format: transpileFormat,
+      minify: transpileMinify,
+      naming: {
+        asset: "[name]-[hash].[ext]",
+        chunk: "[name]-[hash].[ext]",
+        entry: "[dir]/[name]-[hash].[ext]"
+      },
+      outdir: outDirBin,
+      publicPath: transpilePublicPath || "/",
+      sourcemap: getBunSourcemapOption(transpileSourcemap),
+      splitting: transpileSplitting,
+      target: transpileTarget,
+      throw: true
+    });
+    const duration = getElapsedPerfTime(timer);
+    const transpileFormattedDuration = prettyMilliseconds(duration, {
+      verbose: true
+    });
+    relinka(
+      "success",
+      `Regular bun build completed in ${transpileFormattedDuration} with ${buildResult.outputs.length} output file(s).`
+    );
+    if (buildResult.logs && buildResult.logs.length > 0) {
+      buildResult.logs.forEach((log, index) => {
+        relinka("verbose", `Log ${index + 1}: ${JSON.stringify(log)}`);
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka(
+      "error",
+      `Regular build failed while using bun bundler: ${errorMessage}`
+    );
+    const enhancedError = new Error(
+      `Regular bundle failed for ${outDirBin}: ${errorMessage}`
+    );
+    if (error instanceof Error && error.stack) {
+      enhancedError.stack = error.stack;
+    }
+    throw enhancedError;
+  }
+}
+async function regular_bundleUsingJsr(src, dest) {
+  relinka("info", `Starting regular_bundleUsingJsr: ${src} -> ${dest}`);
+  await ensuredir(path.dirname(dest));
+  const stats = await fs.stat(src);
+  if (!stats.isDirectory()) {
+    throw new Error(
+      "You are using the 'jsr' builder, but path to file was provided. Please provide path to directory instead."
+    );
+  }
+  try {
+    await fs.copy(src, dest);
+    relinka("verbose", `Copied directory from ${src} to ${dest}`);
+    relinka("success", "Completed regular JSR bundling");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka("warn", `${errorMessage}, falling back to copying ${src}`);
+    await fs.copy(src, dest);
+  }
+}
+async function regular_bundleUsingUnified(coreEntryFile, outDirBin, builder, unifiedBundlerOutExt, coreEntrySrcDir, transpileStub, transpileWatch, transpileTarget, transpileMinify, transpileSourcemap, timer, coreDeclarations) {
+  if (builder === "jsr" || builder === "bun") {
+    throw new Error(
+      "'jsr'/'bun' builder not supported for regular_bundleUsingUnified"
+    );
+  }
+  try {
+    relinka(
+      "verbose",
+      `Starting regular_bundleUsingUnified (builder: ${builder}): ${coreEntryFile} -> ${outDirBin}`
+    );
+    const rootDir = path.resolve(PROJECT_ROOT, coreEntrySrcDir || ".");
+    if (!validExtensions.includes(unifiedBundlerOutExt)) {
+      throw new Error(`Invalid output extension: ${unifiedBundlerOutExt}`);
+    }
+    const input = builder === "mkdist" ? path.dirname(coreEntryFile) : coreEntryFile;
+    const unifiedBuildConfig = {
+      clean: false,
+      concurrency: CONCURRENCY_DEFAULT,
+      declaration: coreDeclarations,
+      entries: [
+        {
+          builder,
+          ext: unifiedBundlerOutExt,
+          input: builder === "mkdist" ? rootDir : input,
+          outDir: outDirBin
+        }
+      ],
+      rollup: {
+        emitCJS: false,
+        esbuild: {
+          minify: transpileMinify,
+          target: transpileTarget
+        },
+        inlineDependencies: true,
+        output: {
+          sourcemap: getUnifiedSourcemapOption(transpileSourcemap)
+        }
+      },
+      showOutLog: true,
+      transpileStub,
+      transpileWatch: transpileWatch ?? false
+    };
+    await unifiedBuild(rootDir, unifiedBuildConfig, outDirBin);
+    const duration = getElapsedPerfTime(timer);
+    const transpileFormattedDuration = prettyMilliseconds(duration, {
+      verbose: true
+    });
+    relinka(
+      "success",
+      `Regular bundle completed in ${transpileFormattedDuration} using ${builder} builder`
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka(
+      "error",
+      `Failed to bundle regular project using ${builder}: ${errorMessage}`
+    );
+    const enhancedError = new Error(
+      `Regular bundle failed for ${outDirBin}: ${errorMessage}`
+    );
+    if (error instanceof Error && error.stack) {
+      enhancedError.stack = error.stack;
+    }
+    throw enhancedError;
+  }
+}
+async function regular_bundleWithBuilder(builder, params) {
+  const {
+    coreDeclarations,
+    outDir,
+    singleFile,
+    srcDir,
+    timer,
+    transpileFormat,
+    transpileMinify,
+    transpilePublicPath,
+    transpileSourcemap,
+    transpileSplitting,
+    transpileStub,
+    transpileTarget,
+    transpileWatch,
+    unifiedBundlerOutExt
+  } = params;
+  if (builder === "jsr") {
+    await regular_bundleUsingJsr(srcDir, outDir);
+    return;
+  }
+  if (builder === "bun") {
+    await regular_bundleUsingBun(
+      singleFile,
+      outDir,
+      transpileTarget,
+      transpileFormat,
+      transpileSplitting,
+      transpileMinify,
+      transpileSourcemap,
+      transpilePublicPath,
+      timer
+    );
+    return;
+  }
+  await regular_bundleUsingUnified(
+    singleFile,
+    outDir,
+    builder,
+    unifiedBundlerOutExt,
+    // For mkdist, we pass the directory. For others, we pass the single file
+    path.dirname(singleFile),
+    transpileStub,
+    transpileWatch,
+    transpileTarget,
+    transpileMinify,
+    transpileSourcemap,
+    timer,
+    coreDeclarations
+  );
+}
+async function regular_performCommonBuildSteps({
+  coreIsCLI,
+  deleteFiles = true,
+  isJsr,
+  outDirBin,
+  outDirRoot,
+  rmDepsMode,
+  unifiedBundlerOutExt
+}) {
+  await convertImportPaths({
+    aliasPrefix: "~/",
+    baseDir: outDirBin,
+    fromType: "alias",
+    libsList: {},
+    toType: "relative"
+  });
+  if (deleteFiles) {
+    await deleteSpecificFiles(outDirBin);
+  }
+  await regular_createPackageJSON(
+    outDirRoot,
+    isJsr,
+    coreIsCLI,
+    unifiedBundlerOutExt,
+    rmDepsMode,
+    []
+  );
+  await copyRootFile(outDirRoot, ["README.md", "LICENSE"]);
+  if (isJsr) {
+    await copyRootFile(outDirRoot, [
+      ".gitignore",
+      ".config/rse.ts",
+      ".config/rse.jsonc",
+      "drizzle.config.ts",
+      "schema.json"
+    ]);
+  }
+}

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

@@ -0,0 +1,110 @@
+import { relinka } from "@reliverse/relinka";
+import { existsSync } from "node:fs";
+import { join, normalize, resolve } from "pathe";
+import { definePreset } from "./types.js";
+import { extractExportFilenames, listRecursively, warn } from "./utils.js";
+export const autoPreset = definePreset(() => {
+  return {
+    hooks: {
+      "build:prepare"(ctx) {
+        if (!ctx.pkg || ctx.options.entries.length > 0) {
+          return;
+        }
+        const sourceFiles = listRecursively(join(ctx.options.rootDir, "src"));
+        const res = inferEntries(ctx.pkg, sourceFiles, ctx.options.rootDir);
+        for (const message of res.warnings) {
+          warn(ctx, message);
+        }
+        ctx.options.entries.push(...res.entries);
+        if (res.cjs) {
+          ctx.options.rollup.emitCJS = true;
+        }
+        if (ctx.options.declaration === void 0) {
+          ctx.options.declaration = res.dts ? "compatible" : false;
+        }
+        relinka(
+          "info",
+          "Automatically detected entries:",
+          ctx.options.entries.map(
+            (e) => e.input.replace(`${ctx.options.rootDir}/`, "").replace(/\/$/, "/*")
+          ).join(", "),
+          ["esm", res.cjs && "cjs", res.dts && "dts"].filter(Boolean).map((tag) => `[${tag}]`).join(" ")
+        );
+      }
+    }
+  };
+});
+const getEntrypointPaths = (path) => {
+  const segments = normalize(path).split("/");
+  return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
+};
+function inferEntries(pkg, sourceFiles, rootDir) {
+  const warnings = [];
+  sourceFiles.sort((a, b) => a.split("/").length - b.split("/").length);
+  const outputs = extractExportFilenames(pkg.exports);
+  if (pkg.bin) {
+    const binaries = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
+    for (const file of binaries) {
+      outputs.push({ file });
+    }
+  }
+  if (pkg.main) {
+    outputs.push({ file: pkg.main });
+  }
+  if (pkg.module) {
+    outputs.push({ file: pkg.module, type: "esm" });
+  }
+  if (pkg.types || pkg.typings) {
+    outputs.push({ file: pkg.types || pkg.typings });
+  }
+  const isESMPkg = pkg.type === "module";
+  for (const output of outputs.filter((o) => !o.type)) {
+    const isJS = output.file.endsWith(".js");
+    if (isESMPkg && isJS || output.file.endsWith(".mjs")) {
+      output.type = "esm";
+    } else if (!isESMPkg && isJS || output.file.endsWith(".cjs")) {
+      output.type = "cjs";
+    }
+  }
+  let cjs = false;
+  let dts = false;
+  const entries = [];
+  for (const output of outputs) {
+    const outputSlug = output.file.replace(
+      /(\*[^/\\]*|\.d\.(m|c)?ts|\.\w+)$/,
+      ""
+    );
+    const isDir = outputSlug.endsWith("/");
+    if (isDir && ["./", "/"].includes(outputSlug)) {
+      continue;
+    }
+    const possiblePaths = getEntrypointPaths(outputSlug);
+    const input = possiblePaths.reduce((source, d) => {
+      if (source) {
+        return source;
+      }
+      const SOURCE_RE = new RegExp(
+        `(?<=/|$)${d}${isDir ? "" : String.raw`\.\w+`}$`
+      );
+      return sourceFiles.find((i) => SOURCE_RE.test(i))?.replace(/(\.d\.(m|c)?ts|\.\w+)$/, "");
+    }, void 0);
+    if (!input) {
+      if (!existsSync(resolve(rootDir || ".", output.file))) {
+        warnings.push(`Could not find entrypoint for \`${output.file}\``);
+      }
+      continue;
+    }
+    if (output.type === "cjs") {
+      cjs = true;
+    }
+    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input }) - 1];
+    if (/\.d\.(m|c)?ts$/.test(output.file)) {
+      dts = true;
+    }
+    if (isDir && entry) {
+      entry.outDir = outputSlug;
+      entry.format = output.type;
+    }
+  }
+  return { cjs, dts, entries, warnings };
+}