@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,626 +0,0 @@
-import path, {
-  convertImportsAliasToRelative,
-  convertImportsExt,
-  stripPathSegmentsInDirectory
-} from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { build as bunBuild } from "bun";
-import pAll from "p-all";
-import prettyBytes from "pretty-bytes";
-import prettyMilliseconds from "pretty-ms";
-import { unifiedBuild } from "./providers/build.js";
-import { CONCURRENCY_DEFAULT, PROJECT_ROOT, validExtensions } from "../config/constants.js";
-import { getBunSourcemapOption, getUnifiedSourcemapOption } from "../utils/utils-build.js";
-import { removeLogInternalCalls } from "../utils/utils-clean.js";
-import { determineDistName } from "../utils/utils-determine.js";
-import {
-  copyRootFile,
-  deleteSpecificFiles,
-  getDirectorySize,
-  outDirBinFilesCount
-} from "../utils/utils-fs.js";
-import { createJsrJSON, renameTsxFiles } from "../utils/utils-jsr-json.js";
-import { library_createPackageJSON } from "../utils/utils-package-json-libraries.js";
-import { getElapsedPerfTime } from "../utils/utils-perf.js";
-const BIN_DIR_NAME = "bin";
-const ALIAS_PREFIX_TO_CONVERT = "~";
-export async function library_buildLibrary(options) {
-  const { libName } = options;
-  try {
-    await executeBuildTasks(options);
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    relinka("error", `Build process for ${libName} failed: ${error.message}`);
-    throw error;
-  }
-}
-async function executeBuildTasks(options) {
-  const { libName, npm, jsr, effectivePubRegistry } = options;
-  relinka("verbose", `Executing build tasks for ${libName} (Registry: ${effectivePubRegistry})...`);
-  const buildTasks = [];
-  if (effectivePubRegistry === "jsr" || effectivePubRegistry === "npm-jsr") {
-    if (!jsr) {
-      throw new Error(
-        `Build Error (executeBuildTasks): JSR config missing for ${libName} when registry includes JSR.`
-      );
-    }
-    buildTasks.push(() => library_buildJsrDist(options));
-  }
-  if (effectivePubRegistry === "npm" || effectivePubRegistry === "npm-jsr") {
-    if (!npm) {
-      throw new Error(
-        `Build Error (executeBuildTasks): NPM config missing for ${libName} when registry includes NPM.`
-      );
-    }
-    buildTasks.push(() => library_buildNpmDist(options));
-  }
-  if (buildTasks.length === 0) {
-    relinka("warn", `No build tasks for ${libName} based on registry: ${effectivePubRegistry}`);
-    return;
-  }
-  await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
-  relinka("success", `All build tasks completed for ${libName}.`);
-}
-async function library_buildJsrDist(options) {
-  const { libName, libMainFile, libsList } = options;
-  if (!options.jsr) {
-    throw new Error(
-      `Internal Error: library_buildJsrDist called for ${libName} but options.jsr is missing.`
-    );
-  }
-  const jsrOptions = options.jsr;
-  const { jsrOutDir, distJsrBuilder, distJsrOutFilesExt } = jsrOptions;
-  const targetType = "jsr";
-  relinka("verbose", `[JSR] Initializing JSR build for ${libName}...`);
-  const libSourceDirResolved = path.resolve(PROJECT_ROOT, options.mainDir);
-  const entryFilePathResolved = path.resolve(libSourceDirResolved, libMainFile);
-  const outputDirRootResolved = path.resolve(PROJECT_ROOT, jsrOutDir);
-  const outputDirBinResolved = path.resolve(outputDirRootResolved, BIN_DIR_NAME);
-  await fs.ensureDir(outputDirRootResolved);
-  await fs.ensureDir(outputDirBinResolved);
-  const bundlerEntryPoint = distJsrBuilder === "jsr" ? libSourceDirResolved : entryFilePathResolved;
-  const libConfig = libsList[libName];
-  const libDeclarations = libConfig?.libDeclarations ?? false;
-  const actualLibDirName = libConfig?.libDirName;
-  if (!actualLibDirName) {
-    relinka(
-      "warn",
-      `[JSR:${libName}] libDirName not found in libConfig. Path stripping in common steps might be affected.`
-    );
-  }
-  const buildParams = {
-    targetType,
-    builder: distJsrBuilder,
-    libSourceDir: libSourceDirResolved,
-    entryFilePath: bundlerEntryPoint,
-    outputDirRoot: outputDirRootResolved,
-    outputDirBin: outputDirBinResolved,
-    libDeclarations,
-    distJsrOutFilesExt,
-    options,
-    libDirName: actualLibDirName
-  };
-  await library_buildDistributionTarget(buildParams);
-  relinka("verbose", `[JSR] Performing JSR-specific transformations in ${outputDirBinResolved}`);
-  await createJsrJSON(
-    outputDirRootResolved,
-    true,
-    options.libsList,
-    options,
-    libName,
-    libConfig?.libDescription ?? ""
-  );
-  await renameTsxFiles(outputDirBinResolved);
-  const dirSize = await getDirectorySize(outputDirRootResolved, options.isDev);
-  const filesCount = await outDirBinFilesCount(outputDirBinResolved);
-  relinka(
-    "success",
-    `[JSR] JSR distribution for ${libName} built successfully (${filesCount} files, ${prettyBytes(dirSize)}) -> ${outputDirRootResolved}`
-  );
-}
-async function library_buildNpmDist(options) {
-  const { libName, libMainFile, libsList } = options;
-  if (!options.npm) {
-    throw new Error(
-      `Internal Error: library_buildNpmDist called for ${libName} but options.npm is missing.`
-    );
-  }
-  const npmOptions = options.npm;
-  const { npmOutDir, distNpmBuilder, coreEntrySrcDir } = npmOptions;
-  const distJsrOutFilesExt = options.jsr?.distJsrOutFilesExt || "ts";
-  const targetType = "npm";
-  const distName = determineDistName(npmOutDir, false, libsList);
-  relinka("verbose", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
-  const outputDirRootResolved = path.resolve(PROJECT_ROOT, npmOutDir);
-  const outputDirBinResolved = path.resolve(outputDirRootResolved, BIN_DIR_NAME);
-  await fs.ensureDir(outputDirRootResolved);
-  await fs.ensureDir(outputDirBinResolved);
-  const { libSpecificSrcDir, libDirName } = await determineNpmSourceDirectory(
-    libName,
-    libMainFile,
-    path.resolve(PROJECT_ROOT, coreEntrySrcDir),
-    libsList,
-    distName
-  );
-  const entryFilePathResolved = path.resolve(libSpecificSrcDir, path.basename(libMainFile));
-  if (!await fs.pathExists(entryFilePathResolved)) {
-    const relativeEntryPath = path.relative(PROJECT_ROOT, entryFilePathResolved);
-    const relativeSrcDir = path.relative(PROJECT_ROOT, libSpecificSrcDir);
-    throw new Error(
-      `[NPM:${distName}] Library entry file not found: ${relativeEntryPath} (expected in: ${relativeSrcDir})`
-    );
-  }
-  relinka("verbose", `[NPM:${distName}] Using entry file: ${entryFilePathResolved}`);
-  const libConfig = libsList[libName];
-  const libDeclarations = libConfig?.libDeclarations ?? false;
-  const buildParams = {
-    targetType,
-    builder: distNpmBuilder,
-    libSourceDir: libSpecificSrcDir,
-    entryFilePath: entryFilePathResolved,
-    outputDirRoot: outputDirRootResolved,
-    outputDirBin: outputDirBinResolved,
-    libDeclarations,
-    distJsrOutFilesExt,
-    options,
-    libDirName
-  };
-  await library_buildDistributionTarget(buildParams);
-  const dirSize = await getDirectorySize(outputDirRootResolved, options.isDev);
-  const filesCount = await outDirBinFilesCount(outputDirBinResolved);
-  relinka(
-    "success",
-    `[NPM:${distName}] NPM distribution for ${libName} built successfully (${filesCount} files, ${prettyBytes(dirSize)}) -> ${outputDirRootResolved}`
-  );
-}
-async function library_buildDistributionTarget(params) {
-  const {
-    targetType,
-    builder,
-    entryFilePath,
-    // Entry for bundler (file path or dir path for 'jsr' copy)
-    outputDirRoot,
-    outputDirBin,
-    libDeclarations,
-    distJsrOutFilesExt,
-    options,
-    libDirName,
-    npmOutDir,
-    jsrOutDir
-  } = params;
-  const {
-    libName,
-    timer,
-    libMainFile,
-    libsList,
-    // Transpile/Bundle Options from `options`
-    libTranspileMinify,
-    transpileTarget,
-    transpileFormat,
-    transpileSourcemap,
-    transpilePublicPath,
-    transpileEsbuild,
-    transpileStub,
-    transpileWatch,
-    unifiedBundlerOutExt
-  } = options;
-  const isJsr = targetType === "jsr";
-  const logPrefix = isJsr ? "[JSR]" : `[NPM:${determineDistName(path.relative(PROJECT_ROOT, outputDirRoot), false, libsList)}]`;
-  relinka("verbose", `${logPrefix} Starting build target processing...`);
-  await fs.ensureDir(outputDirRoot);
-  await fs.ensureDir(outputDirBin);
-  relinka("verbose", `${logPrefix} Using builder: ${builder}`);
-  const bundleRequest = {
-    builder,
-    entryPoint: entryFilePath,
-    outDir: outputDirBin,
-    libName,
-    timer,
-    libDeclarations,
-    libTranspileMinify,
-    transpileTarget,
-    transpileFormat,
-    transpileSourcemap,
-    transpilePublicPath,
-    transpileEsbuild,
-    transpileStub,
-    transpileWatch,
-    unifiedBundlerOutExt
-  };
-  await library_bundleWithBuilder(bundleRequest);
-  const commonStepsParams = {
-    coreEntryFileName: path.basename(libMainFile),
-    outputDirRoot,
-    outDirBin: outputDirBin,
-    isJsr,
-    libName,
-    libsList,
-    config: options,
-    unifiedBundlerOutExt,
-    distJsrOutFilesExt,
-    deleteFiles: isJsr,
-    libDirName,
-    npmOutputDirRoot: npmOutDir || (options.npm ? options.npm.npmOutDir : void 0),
-    jsrOutputDirRoot: jsrOutDir || (options.jsr ? options.jsr.jsrOutDir : void 0),
-    effectivePubRegistry: options.effectivePubRegistry
-  };
-  await library_performCommonBuildSteps(commonStepsParams);
-  relinka("verbose", `${logPrefix} Completed build target processing.`);
-}
-async function library_bundleWithBuilder(params) {
-  const { builder, ...executorParams } = params;
-  const { entryPoint, outDir, libName } = executorParams;
-  relinka(
-    "verbose",
-    `[${libName}] Bundling using '${builder}' builder... Entry: ${entryPoint}, Out: ${outDir}`
-  );
-  switch (builder) {
-    case "jsr":
-      await library_bundleUsingJsrCopy(entryPoint, outDir, libName);
-      break;
-    case "bun":
-      await library_bundleUsingBun(entryPoint, outDir, libName, {
-        timer: executorParams.timer,
-        libTranspileMinify: executorParams.libTranspileMinify,
-        transpileTarget: executorParams.transpileTarget,
-        transpileFormat: executorParams.transpileFormat,
-        transpileSourcemap: executorParams.transpileSourcemap,
-        transpilePublicPath: executorParams.transpilePublicPath
-      });
-      break;
-    case "rollup":
-    case "mkdist":
-      await library_bundleUsingUnified(
-        entryPoint,
-        outDir,
-        builder,
-        path.dirname(entryPoint),
-        // Source directory context
-        {
-          timer: executorParams.timer,
-          libDeclarations: executorParams.libDeclarations,
-          libTranspileMinify: executorParams.libTranspileMinify,
-          transpileSourcemap: executorParams.transpileSourcemap,
-          transpileEsbuild: executorParams.transpileEsbuild,
-          transpileStub: executorParams.transpileStub,
-          unifiedBundlerOutExt: executorParams.unifiedBundlerOutExt
-        }
-      );
-      break;
-    default:
-      throw new Error(`Unsupported library builder specified: ${builder}`);
-  }
-  relinka("verbose", `[${libName}] Bundling finished using '${builder}'.`);
-}
-async function library_bundleUsingJsrCopy(srcDir, destDir, libName) {
-  relinka("verbose", `[JSR Copy:${libName}] Starting copy: ${srcDir} -> ${destDir}`);
-  await fs.ensureDir(destDir);
-  try {
-    const files = await fs.readdir(srcDir, { withFileTypes: true });
-    for (const file of files) {
-      const srcPath = path.join(srcDir, file.name);
-      const destPath = path.join(destDir, file.name);
-      if (file.isDirectory()) {
-        await fs.copy(srcPath, destPath, { overwrite: true });
-      } else {
-        await fs.copy(srcPath, destPath, { overwrite: true });
-      }
-    }
-    relinka(
-      "success",
-      `[JSR Copy:${libName}] Completed copying library source from ${srcDir} to ${destDir}`
-    );
-  } catch (error) {
-    relinka(
-      "error",
-      `Failed to copy library source from ${srcDir} to ${destDir}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-async function library_bundleUsingBun(entryPoint, outDirBin, libName, options) {
-  const {
-    timer,
-    libTranspileMinify,
-    transpileTarget,
-    transpileFormat,
-    transpileSourcemap,
-    transpilePublicPath
-  } = options;
-  relinka("verbose", `[Bun:${libName}] Starting Bun build...`);
-  if (!await fs.pathExists(entryPoint)) {
-    throw new Error(`[Bun:${libName}] Library entry file not found: ${entryPoint}`);
-  }
-  if (!(await fs.stat(entryPoint)).isFile()) {
-    throw new Error(`[Bun:${libName}] Entry point must be a file for Bun bundler: ${entryPoint}`);
-  }
-  try {
-    const buildConfig = {
-      entrypoints: [entryPoint],
-      outdir: outDirBin,
-      target: transpileTarget,
-      format: transpileFormat,
-      minify: libTranspileMinify,
-      sourcemap: getBunSourcemapOption(transpileSourcemap),
-      publicPath: transpilePublicPath,
-      naming: {
-        entry: "[dir]/[name].[ext]",
-        chunk: "[name]-[hash].[ext]",
-        asset: "[name]-[hash].[ext]"
-      },
-      define: {
-        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production")
-      },
-      plugins: [],
-      loader: {},
-      banner: `/* ${libName} - Bundled by @reliverse/dler (Bun) */`,
-      throw: true
-      // Ensure build errors are thrown
-    };
-    const buildResult = await bunBuild(buildConfig);
-    const duration = getElapsedPerfTime(timer);
-    if (buildResult.success) {
-      relinka(
-        "success",
-        `[Bun:${libName}] Library build completed in ${prettyMilliseconds(duration)} (${buildResult.outputs.length} outputs).`
-      );
-      if (buildResult.logs?.length > 0) {
-        for (const log of buildResult.logs) {
-          relinka("verbose", `[Bun Log:${log.level}] ${log.message}`);
-        }
-      }
-    } else {
-      relinka(
-        "error",
-        `[Bun:${libName}] Library build failed after ${prettyMilliseconds(duration)}.`
-      );
-      if (buildResult.logs?.length > 0) {
-        for (const log of buildResult.logs) {
-          relinka("error", `[Bun Log:${log.level}] ${log.message}`);
-        }
-      }
-      throw new Error(`[Bun:${libName}] Build process reported failure. Check logs.`);
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      `Library build threw an error: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-async function library_bundleUsingUnified(entryPoint, outDirBin, builder, _sourceDirContext, options) {
-  const {
-    timer,
-    libDeclarations,
-    libTranspileMinify,
-    transpileSourcemap,
-    transpileEsbuild,
-    transpileStub,
-    unifiedBundlerOutExt
-  } = options;
-  relinka("verbose", `[Unified:${builder}] Starting ${builder} build...`);
-  const rootDir = PROJECT_ROOT;
-  let validatedExt = unifiedBundlerOutExt;
-  if (!validExtensions.includes(validatedExt)) {
-    relinka(
-      "warn",
-      `[Unified:${builder}] Invalid output extension '${validatedExt}', defaulting to 'js'.`
-    );
-    validatedExt = "js";
-  }
-  const inputRelative = path.relative(rootDir, entryPoint);
-  const outDirRelative = path.relative(rootDir, outDirBin);
-  const unifiedBuildConfig = {
-    clean: false,
-    declaration: libDeclarations ? "compatible" : false,
-    entries: [
-      {
-        builder,
-        input: inputRelative,
-        outDir: outDirRelative,
-        ext: validatedExt,
-        isLib: true
-      }
-    ],
-    rollup: {
-      emitCJS: false,
-      esbuild: {
-        minify: libTranspileMinify,
-        target: transpileEsbuild
-      },
-      inlineDependencies: true,
-      output: {
-        sourcemap: getUnifiedSourcemapOption(transpileSourcemap)
-      }
-    },
-    hooks: {},
-    stub: transpileStub
-  };
-  try {
-    await unifiedBuild(
-      entryPoint,
-      { enabled: false, scripts: {} },
-      true,
-      rootDir,
-      unifiedBuildConfig,
-      outDirBin
-    );
-    const duration = getElapsedPerfTime(timer);
-    relinka(
-      "success",
-      `[Unified:${builder}] Library build completed in ${prettyMilliseconds(duration)}.`
-    );
-  } catch (error) {
-    relinka(
-      "error",
-      `Library build failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-async function library_performCommonBuildSteps(params) {
-  const {
-    coreEntryFileName,
-    outputDirRoot,
-    outDirBin,
-    isJsr,
-    libName,
-    libsList,
-    config,
-    unifiedBundlerOutExt,
-    distJsrOutFilesExt,
-    deleteFiles = false,
-    libDirName,
-    npmOutputDirRoot,
-    jsrOutputDirRoot,
-    effectivePubRegistry
-  } = params;
-  const targetType = isJsr ? "JSR" : "NPM";
-  const logPrefix = `[Common:${targetType}:${libName}]`;
-  relinka(
-    "verbose",
-    `${logPrefix} Performing common steps in ${outputDirRoot}. Entry file: ${coreEntryFileName}. ${isJsr ? `JSR out files ext: ${distJsrOutFilesExt}` : `NPM out files ext: ${unifiedBundlerOutExt}`}`
-  );
-  await library_createPackageJSON(
-    libName,
-    npmOutputDirRoot || outputDirRoot,
-    jsrOutputDirRoot || outputDirRoot,
-    effectivePubRegistry,
-    libsList,
-    config,
-    unifiedBundlerOutExt
-  );
-  relinka("verbose", `${logPrefix} Created package.json.`);
-  await removeLogInternalCalls(outDirBin);
-  if (deleteFiles) {
-    await deleteSpecificFiles(outDirBin);
-    relinka("verbose", `${logPrefix} Deleted specific files from ${outDirBin}.`);
-  }
-  const filesToCopy = isJsr ? config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr || config.publishArtifacts?.["dist-jsr"] || ["jsr.json"] : config.publishArtifacts?.["dist-libs"]?.[libName]?.npm || config.publishArtifacts?.["dist-npm"] || [];
-  const globalFiles = config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"];
-  const allFilesToCopy = [.../* @__PURE__ */ new Set([...globalFiles, ...filesToCopy])];
-  await copyRootFile(outputDirRoot, allFilesToCopy);
-  relinka(
-    "verbose",
-    `${logPrefix} Copied root files (${allFilesToCopy.join(", ")}) to ${outputDirRoot}`
-  );
-  const stripSegments = libDirName ? [`libs/${libDirName}`] : [];
-  relinka(
-    "verbose",
-    `${logPrefix} Converting alias paths in ${outDirBin}, stripping: [${stripSegments.join(", ")}]`
-  );
-  relinka("info", `[${libName}] Stripping segments`);
-  await stripPathSegmentsInDirectory({
-    targetDir: outDirBin,
-    segmentsToStrip: 2,
-    alias: ALIAS_PREFIX_TO_CONVERT
-  });
-  relinka("info", `[${libName}] Performing alias path conversion in ${outDirBin}`);
-  await convertImportsAliasToRelative({
-    targetDir: outDirBin,
-    aliasToReplace: ALIAS_PREFIX_TO_CONVERT,
-    pathExtFilter: "js-ts-none"
-  });
-  if (isJsr) {
-    relinka("info", `[${libName}] Performing paths ext conversion in ${outDirBin} (from js to ts)`);
-    await convertImportsExt({
-      targetDir: outDirBin,
-      extFrom: "js",
-      extTo: "ts"
-    });
-    await convertImportsExt({
-      targetDir: outDirBin,
-      extFrom: "none",
-      extTo: "ts"
-    });
-  }
-  relinka("verbose", `${logPrefix} Completed common build steps.`);
-}
-async function determineNpmSourceDirectory(libName, _mainFile, coreEntrySrcDirResolved, libsList, distName) {
-  const logPrefix = `[NPM:${distName}:${libName}]`;
-  const libConfig = libsList?.[libName];
-  let libSpecificSrcDir = coreEntrySrcDirResolved;
-  let libDirName;
-  if (libConfig?.libMainFile) {
-    if (libConfig.libDirName) {
-      const potentialLibDirName = libConfig.libDirName;
-      const potentialPath = path.join(coreEntrySrcDirResolved, "libs", potentialLibDirName);
-      if (await fs.pathExists(potentialPath)) {
-        libSpecificSrcDir = potentialPath;
-        libDirName = potentialLibDirName;
-        relinka(
-          "verbose",
-          `${logPrefix} Using explicit libDirName '${libDirName}' to set source dir: ${libSpecificSrcDir}`
-        );
-      } else {
-        relinka(
-          "warn",
-          `${logPrefix} Explicit libDirName '${potentialLibDirName}' provided, but path not found: ${potentialPath}. Falling back.`
-        );
-        libDirName = void 0;
-      }
-    } else {
-      const baseLibsDir = path.join(PROJECT_ROOT, "src", "libs");
-      try {
-        const absoluteLibMainFile = path.resolve(PROJECT_ROOT, libConfig.libMainFile);
-        if (absoluteLibMainFile.startsWith(baseLibsDir + path.sep)) {
-          const mainFilePathRelative = path.relative(baseLibsDir, absoluteLibMainFile);
-          const pathSegments = mainFilePathRelative.split(path.sep);
-          if (pathSegments.length > 1) {
-            const inferredDirName = pathSegments[0];
-            const potentialPath = inferredDirName ? path.join(baseLibsDir, inferredDirName) : baseLibsDir;
-            if (await fs.pathExists(potentialPath)) {
-              libDirName = inferredDirName;
-              libSpecificSrcDir = potentialPath;
-              relinka(
-                "verbose",
-                `${logPrefix} Inferred libDirName '${libDirName}' from libMainFile. Source dir: ${libSpecificSrcDir}`
-              );
-            } else {
-              relinka(
-                "verbose",
-                `${logPrefix} Inferred directory '${inferredDirName}' from libMainFile does not exist. Falling back.`
-              );
-              libDirName = void 0;
-            }
-          } else {
-            relinka(
-              "verbose",
-              `${logPrefix} libMainFile '${libConfig.libMainFile}' is directly in base libs dir? No specific subdir inferred.`
-            );
-          }
-        } else {
-          relinka(
-            "verbose",
-            `${logPrefix} libMainFile '${libConfig.libMainFile}' is outside the expected '${baseLibsDir}' structure.`
-          );
-        }
-      } catch (pathError) {
-        relinka(
-          "warn",
-          `${logPrefix} Could not reliably determine relative path for ${libConfig.libMainFile}. Falling back. Error: ${pathError instanceof Error ? pathError.message : String(pathError)}`
-        );
-      }
-    }
-  } else {
-    relinka(
-      "verbose",
-      `${logPrefix} No libMainFile configured. Using core source directory: ${coreEntrySrcDirResolved}`
-    );
-  }
-  if (!await fs.pathExists(libSpecificSrcDir)) {
-    relinka(
-      "warn",
-      `${logPrefix} Determined source directory does not exist: ${libSpecificSrcDir}. Falling back to core source dir: ${coreEntrySrcDirResolved}`
-    );
-    libSpecificSrcDir = coreEntrySrcDirResolved;
-    libDirName = void 0;
-  }
-  relinka(
-    "verbose",
-    `${logPrefix} Final determined library source directory: ${libSpecificSrcDir}`
-  );
-  return { libSpecificSrcDir, libDirName };
-}

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

@@ -1,20 +0,0 @@
-import type { BundlerName, NpmOutExt, ReliverseConfig, Sourcemap, TranspileFormat, TranspileTarget } from "../schema/mod.js";
-import type { PerfTimer } from "../types/mod.js";
-/**
- * Builds a regular JSR distribution.
- * - Copies the entire source directory if `distJsrBuilder` = "jsr"
- * - Otherwise uses bun or a "unified" bundler.
- */
-export declare function regular_buildJsrDist(isDev: boolean, isJsr: boolean, coreIsCLI: {
-    enabled: boolean;
-    scripts: Record<string, string>;
-}, coreEntrySrcDir: string, distJsrDirName: string, distJsrBuilder: BundlerName, coreEntryFile: string, transpileTarget: TranspileTarget, transpileFormat: TranspileFormat, transpileMinify: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, unifiedBundlerOutExt: NpmOutExt, config: ReliverseConfig, timer: PerfTimer, transpileStub: boolean, transpileWatch: boolean, distJsrGenTsconfig: boolean, coreDeclarations: boolean): Promise<void>;
-/**
- * Builds a regular NPM distribution.
- * - Copies entire src dir if "jsr"
- * - Otherwise uses Bun or a unified builder
- */
-export declare function regular_buildNpmDist(isDev: boolean, coreIsCLI: {
-    enabled: boolean;
-    scripts: Record<string, string>;
-}, coreEntrySrcDir: string, distNpmDirName: string, distNpmBuilder: BundlerName, coreEntryFile: string, unifiedBundlerOutExt: NpmOutExt, config: ReliverseConfig, transpileTarget: TranspileTarget, transpileFormat: TranspileFormat, transpileMinify: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, transpileStub: boolean, transpileWatch: boolean, timer: PerfTimer, coreDeclarations: boolean): Promise<void>;