@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/build/library-flow.d.ts

@@ -1,26 +0,0 @@
-import type { BundlerName, Esbuild, LibConfig, NpmOutExt, ReliverseConfig, Sourcemap, TranspileFormat, TranspileTarget } from "../schema/mod.js";
-import type { PerfTimer } from "../types/mod.js";
-/**
- * Builds libraries based on build mode.
- */
-export declare function library_buildFlow(timer: PerfTimer, isDev: boolean, config: ReliverseConfig): Promise<void>;
-/**
- * Publishes libraries based on build mode.
- */
-export declare function library_pubFlow(timer: PerfTimer, isDev: boolean, config: ReliverseConfig): Promise<void>;
-/**
- * Builds all libs defined in config.libsList.
- */
-export declare function libraries_build(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, libsDirDist: string, libsDirSrc: string, commonPubRegistry: "jsr" | "npm" | "npm-jsr", unifiedBundlerOutExt: NpmOutExt, distNpmBuilder: BundlerName, coreEntrySrcDir: string, filterDepsPatterns: {
-    global: string[];
-    "dist-npm": string[];
-    "dist-jsr": string[];
-    "dist-libs": Record<string, {
-        npm: string[];
-        jsr: string[];
-    }>;
-}, transpileEsbuild: Esbuild, transpileTarget: TranspileTarget, transpileFormat: TranspileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt, config: ReliverseConfig): Promise<void>;
-/**
- * Publishes all libs defined in config.libsList.
- */
-export declare function libraries_publish(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, commonPubPause: boolean, commonPubRegistry: "jsr" | "npm" | "npm-jsr", distJsrAllowDirty: boolean, distJsrSlowTypes: boolean, shouldShowSpinner?: boolean): Promise<void>;

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

@@ -1,252 +0,0 @@
-import path from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { createSpinnerGroup } from "@reliverse/rempts";
-import pAll from "p-all";
-import { library_buildLibrary } from "./build-library.js";
-import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
-import { library_publishLibrary } from "../pub/pub-library.js";
-import { resumePerfTimer } from "../utils/utils-perf.js";
-export async function library_buildFlow(timer, isDev, config) {
-  relinka("verbose", "\u2014 \u2014 \u2014 library_buildFlow \u2014 \u2014 \u2014");
-  if (config.libsActMode !== "libs-only" && config.libsActMode !== "main-and-libs") {
-    relinka("verbose", "Skipping libs build as libsActMode is set to 'main-project-only'");
-    return;
-  }
-  await libraries_build(
-    isDev,
-    timer,
-    config.libsList,
-    config.libsDirDist,
-    config.libsDirSrc,
-    config.commonPubRegistry,
-    config.distNpmOutFilesExt,
-    config.distNpmBuilder,
-    config.coreEntrySrcDir,
-    config.filterDepsPatterns,
-    config.transpileEsbuild,
-    config.transpileTarget,
-    config.transpileFormat,
-    config.transpileSplitting,
-    config.transpileSourcemap,
-    config.transpilePublicPath,
-    config.distJsrBuilder,
-    config.transpileStub,
-    config.transpileWatch,
-    config.distJsrOutFilesExt,
-    config
-  );
-}
-export async function library_pubFlow(timer, isDev, config) {
-  relinka("verbose", "\u2014 \u2014 \u2014 library_pubFlow \u2014 \u2014 \u2014");
-  if (config.libsActMode !== "libs-only" && config.libsActMode !== "main-and-libs") {
-    relinka("verbose", "Skipping libs publish as libsActMode is set to 'main-project-only'");
-    return;
-  }
-  await libraries_publish(
-    isDev,
-    timer,
-    config.libsList,
-    config.distJsrDryRun,
-    config.distJsrFailOnWarn,
-    config.libsDirDist,
-    config.commonPubPause,
-    config.commonPubRegistry,
-    config.distJsrAllowDirty,
-    config.distJsrSlowTypes,
-    config.displayBuildPubLogs === false
-  );
-}
-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_build(isDev, timer, libsList, libsDirDist, libsDirSrc, commonPubRegistry, unifiedBundlerOutExt, distNpmBuilder, coreEntrySrcDir, filterDepsPatterns, transpileEsbuild, transpileTarget, transpileFormat, transpileSplitting, transpileSourcemap, transpilePublicPath, distJsrBuilder, transpileStub, transpileWatch, distJsrOutFilesExt, config) {
-  relinka("verbose", "Starting libraries_build");
-  if (!libsList || Object.keys(libsList).length === 0) {
-    relinka("verbose", "No lib configs found in config, skipping libs build.");
-    return;
-  }
-  const libsEntries = Object.entries(libsList);
-  const shouldShowSpinner = config.displayBuildPubLogs === false;
-  let spinnerGroup = null;
-  if (shouldShowSpinner) {
-    const libraryNames = libsEntries.map(([libName]) => `Building ${libName}`);
-    spinnerGroup = createSpinnerGroup({
-      items: libraryNames,
-      concurrent: true,
-      color: "green"
-    });
-    for (const spinner of spinnerGroup.spinners) {
-      spinner.start();
-    }
-  }
-  const tasks = libsEntries.map(([libName, libConfig], index) => {
-    return async () => {
-      const librarySpinner = spinnerGroup?.spinners[index];
-      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({
-          ...config,
-          effectivePubRegistry: libConfig.libPubRegistry || commonPubRegistry,
-          libName,
-          mainDir: libMainDir,
-          npm: {
-            npmOutDir,
-            distNpmBuilder,
-            coreEntrySrcDir
-          },
-          jsr: {
-            jsrOutDir,
-            distJsrBuilder,
-            distJsrOutFilesExt
-          },
-          libMainFile,
-          isDev,
-          libsList,
-          unifiedBundlerOutExt,
-          filterDepsPatterns,
-          transpileEsbuild,
-          transpileTarget,
-          transpileFormat,
-          transpileSplitting,
-          libTranspileMinify,
-          transpileSourcemap,
-          transpilePublicPath,
-          timer,
-          transpileStub,
-          transpileWatch
-        });
-        if (librarySpinner) {
-          librarySpinner.succeed(`${libName} built successfully`);
-        }
-      } catch (error) {
-        if (librarySpinner) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          librarySpinner.fail(`${libName} build failed: ${errorMessage}`);
-        }
-        relinka(
-          "error",
-          `Failed to build library ${libName}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        throw error;
-      }
-    };
-  });
-  try {
-    await pAll(tasks, {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", "Completed libraries_build");
-  } catch (error) {
-    if (timer) resumePerfTimer(timer);
-    throw error;
-  }
-}
-export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, commonPubPause, commonPubRegistry, distJsrAllowDirty, distJsrSlowTypes, shouldShowSpinner = false) {
-  relinka("verbose", "Starting libraries_publish");
-  if (!libsList || Object.keys(libsList).length === 0) {
-    relinka("verbose", "No lib configs found in config, skipping libs publish.");
-    return;
-  }
-  const libsEntries = Object.entries(libsList);
-  let publishSpinnerGroup = null;
-  if (!commonPubPause) {
-    const libraryNames = libsEntries.filter(([, libConfig]) => !libConfig.libPubPause).map(([libName]) => `Publishing ${libName} to ${commonPubRegistry}`);
-    if (libraryNames.length > 0) {
-      publishSpinnerGroup = createSpinnerGroup({
-        items: libraryNames,
-        concurrent: true,
-        color: "magenta"
-      });
-      for (const spinner of publishSpinnerGroup.spinners) {
-        spinner.start();
-      }
-    }
-  }
-  const tasks = libsEntries.map(([libName, libConfig], index) => {
-    return async () => {
-      const publishSpinner = publishSpinnerGroup?.spinners[index];
-      try {
-        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");
-        if (!commonPubPause && !libConfig.libPubPause) {
-          const effectivePubRegistry = libConfig.libPubRegistry || commonPubRegistry;
-          await library_publishLibrary(
-            effectivePubRegistry,
-            libName,
-            npmOutDir,
-            jsrOutDir,
-            distJsrDryRun,
-            distJsrFailOnWarn,
-            distJsrAllowDirty,
-            distJsrSlowTypes,
-            isDev,
-            timer,
-            shouldShowSpinner
-          );
-          if (publishSpinner) {
-            publishSpinner.succeed(`${libName} published to ${effectivePubRegistry} successfully`);
-          }
-        } else if (libConfig.libPubPause && !commonPubPause) {
-          relinka("verbose", `Publishing is paused for lib ${libName} (libPubPause: true)`);
-          if (publishSpinner) {
-            publishSpinner.info(`${libName} publish paused by configuration`);
-          }
-        }
-      } catch (error) {
-        if (publishSpinner) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          publishSpinner.fail(`${libName} publish failed: ${errorMessage}`);
-        }
-        relinka(
-          "error",
-          `Failed to publish library ${libName}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        throw error;
-      }
-    };
-  });
-  try {
-    await pAll(tasks, {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", "Completed libraries_publish");
-  } catch (error) {
-    if (timer) resumePerfTimer(timer);
-    throw error;
-  }
-}

package/bin/impl/build/postbuild.d.ts

@@ -1,3 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-export declare function dlerPostBuild(isDev: boolean, debugDontCopyNonBuildFiles?: boolean): Promise<void>;
-export declare function wrapper_CopyNonBuildFiles(config: ReliverseConfig): Promise<void>;

package/bin/impl/build/postbuild.js

@@ -1,173 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-import { PROJECT_ROOT } from "../config/constants.js";
-import { getConfigDler } from "../config/load.js";
-import { applyMagicSpells } from "../magic/magic-apply.js";
-import { resolveAllCrossLibs } from "../utils/resolve-cross-libs.js";
-import { directoryExists, executeDlerHooks } from "./ppb-utils.js";
-const ALIAS_TO_REPLACE = "~";
-export async function dlerPostBuild(isDev, debugDontCopyNonBuildFiles) {
-  relinka("verbose", "\u2014 \u2014 \u2014 dlerPostBuild \u2014 \u2014 \u2014");
-  const config = await getConfigDler();
-  await resolveAllCrossLibs(
-    "package",
-    ALIAS_TO_REPLACE,
-    ["npm", "jsr"],
-    config.buildPreExtensions,
-    config.buildTemplatesDir
-  );
-  if (!debugDontCopyNonBuildFiles) {
-    await wrapper_CopyNonBuildFiles(config);
-  }
-  if (isDev) {
-    await applyMagicSpells(["dist-jsr", "dist-npm", "dist-libs"]);
-  }
-  await executeDlerHooks(config?.hooksAfterBuild ?? [], "post-build");
-  if (config?.runAfterBuild?.length) {
-    const tools = createPostBuildToolRunner();
-    const availableTools = config.runAfterBuild.filter((toolName) => toolName in tools).map((toolName) => ({ toolName, ...tools[toolName] }));
-    for (const { name, run } of availableTools) {
-      relinka("verbose", `Running ${name}...`);
-      await run();
-    }
-  }
-  const distJsrPath = path.join(PROJECT_ROOT, config.distJsrDirName);
-  const distJsrBinPath = path.join(distJsrPath, "bin");
-  if (await directoryExists(distJsrPath) && await directoryExists(distJsrBinPath)) {
-    await compareFileStructures(
-      path.join(PROJECT_ROOT, config.coreEntrySrcDir),
-      distJsrPath,
-      isDev
-    );
-  }
-}
-export async function wrapper_CopyNonBuildFiles(config) {
-  if (config.commonPubRegistry === "npm" || config.commonPubRegistry === "npm-jsr") {
-    await copyNonBuildFiles(
-      path.join(PROJECT_ROOT, config.coreEntrySrcDir),
-      path.join(PROJECT_ROOT, config.distNpmDirName),
-      config.buildPreExtensions,
-      config.buildTemplatesDir
-    );
-  }
-  if (config.commonPubRegistry === "jsr" || config.commonPubRegistry === "npm-jsr") {
-    await copyNonBuildFiles(
-      path.join(PROJECT_ROOT, config.coreEntrySrcDir),
-      path.join(PROJECT_ROOT, config.distJsrDirName),
-      config.buildPreExtensions,
-      config.buildTemplatesDir
-    );
-  }
-  if (config.libsActMode === "libs-only" || config.libsActMode === "main-and-libs") {
-    for (const [_, libConfig] of Object.entries(config.libsList)) {
-      const srcPath = path.join(PROJECT_ROOT, config.libsDirSrc, libConfig.libDirName);
-      const distPath = path.join(PROJECT_ROOT, config.libsDirDist, libConfig.libDirName);
-      if (libConfig.libPubRegistry === "npm" || libConfig.libPubRegistry === "npm-jsr") {
-        await copyNonBuildFiles(
-          srcPath,
-          path.join(distPath, "npm"),
-          config.buildPreExtensions,
-          config.buildTemplatesDir
-        );
-      }
-      if (libConfig.libPubRegistry === "jsr" || libConfig.libPubRegistry === "npm-jsr") {
-        await copyNonBuildFiles(
-          srcPath,
-          path.join(distPath, "jsr"),
-          config.buildPreExtensions,
-          config.buildTemplatesDir
-        );
-      }
-    }
-  }
-}
-async function copyNonBuildFiles(srcDir, distDir, preExtensions, templatesDir) {
-  try {
-    const templatesDirs = await glob(`**/${templatesDir}`, {
-      cwd: srcDir,
-      onlyDirectories: true,
-      absolute: true
-    });
-    for (const templateDir of templatesDirs) {
-      const relativePath = path.relative(srcDir, templateDir);
-      const templatesDestPath = path.join(distDir, "bin", relativePath);
-      await fs.ensureDir(path.dirname(templatesDestPath));
-      await fs.copy(templateDir, templatesDestPath);
-    }
-    const files = await glob("**/*", {
-      cwd: srcDir,
-      ignore: [`**/${templatesDir}/**`]
-    });
-    for (const file of files) {
-      const ext = path.extname(file).slice(1);
-      if (!preExtensions.includes(ext)) {
-        const srcPath = path.join(srcDir, file);
-        const binDir = path.join(distDir, "bin");
-        const destPath = path.join(binDir, file);
-        await fs.ensureDir(path.dirname(destPath));
-        await fs.copy(srcPath, destPath);
-      }
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      `Error copying non-build files: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-async function compareFileStructures(srcDir, distDir, isDev) {
-  try {
-    const srcFiles = await glob("**/*", {
-      cwd: srcDir,
-      onlyFiles: true,
-      dot: true
-    });
-    const distBinDir = path.join(distDir, "bin");
-    const distFiles = await glob("**/*", {
-      cwd: distBinDir,
-      onlyFiles: true,
-      dot: true
-    });
-    const filteredSrcFiles = srcFiles.filter(
-      (file) => !file.endsWith(".test.ts") && !file.endsWith(".test.js")
-    );
-    const filteredDistFiles = distFiles.filter(
-      (file) => !file.endsWith(".test.ts") && !file.endsWith(".test.js")
-    );
-    const srcSet = new Set(filteredSrcFiles);
-    const distSet = new Set(filteredDistFiles);
-    const onlyInSrc = [...srcSet].filter((x) => !distSet.has(x));
-    const onlyInDist = [...distSet].filter((x) => !srcSet.has(x));
-    if ((onlyInSrc.length > 0 || onlyInDist.length > 0) && isDev) {
-      relinka("warn", "File structure differences detected between src and dist-jsr/bin:");
-      if (onlyInSrc.length > 0) {
-        relinka("warn", "Files only in src:");
-        for (const file of onlyInSrc) {
-          relinka("warn", `  - ${file}`);
-        }
-      }
-      if (onlyInDist.length > 0) {
-        relinka("warn", "Files only in dist-jsr/bin:");
-        for (const file of onlyInDist) {
-          relinka("warn", `  - ${file}`);
-        }
-      }
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      `Error comparing file structures: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-const createPostBuildToolRunner = () => ({
-  "dler-check": {
-    name: "Dler Check",
-    async run() {
-    }
-  }
-});

package/bin/impl/build/ppb-utils.d.ts

@@ -1,16 +0,0 @@
-export type PackageManager = "bun" | "npm" | "yarn" | "pnpm";
-export declare function getPackageManager(): Promise<PackageManager>;
-/**
- * Checks if a command is available in the system or package.json
- * First checks package.json dependencies, then falls back to global command detection
- */
-export declare function isCommandAvailable(command: string): Promise<boolean>;
-/**
- * Executes a shell command using the appropriate method based on the environment
- */
-export declare function executeCommand(command: string): Promise<void>;
-export declare function directoryExists(dirPath: string): Promise<boolean>;
-/**
- * Executes hooks with consistent error handling and logging
- */
-export declare function executeDlerHooks(hooks: (() => Promise<void>)[], phase: "pre-build" | "post-build"): Promise<void>;

package/bin/impl/build/ppb-utils.js

@@ -1,99 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { selectPrompt } from "@reliverse/rempts";
-import { $ } from "bun";
-import { execa } from "execa";
-import { lookpath } from "lookpath";
-import { readPackageJSON } from "pkg-types";
-const COMMAND_TO_PACKAGE = {
-  tsc: "typescript",
-  eslint: "eslint",
-  biome: "@biomejs/biome",
-  knip: "knip"
-};
-let selectedPackageManager = null;
-export async function getPackageManager() {
-  if (selectedPackageManager) return selectedPackageManager;
-  if (process.versions.bun) {
-    selectedPackageManager = "bun";
-    return selectedPackageManager;
-  }
-  const result = await selectPrompt({
-    title: "Select package manager to use for running tools:",
-    options: [
-      { label: "npm", value: "npm" },
-      { label: "yarn", value: "yarn" },
-      { label: "pnpm", value: "pnpm" }
-    ]
-  });
-  selectedPackageManager = result;
-  return selectedPackageManager;
-}
-async function isCommandInPackageJson(command) {
-  try {
-    const packageJson = await readPackageJSON();
-    const packageName = COMMAND_TO_PACKAGE[command];
-    if (!packageName) return false;
-    return packageName in (packageJson.dependencies || {}) || packageName in (packageJson.devDependencies || {});
-  } catch (_error) {
-    return false;
-  }
-}
-export async function isCommandAvailable(command) {
-  const packageName = COMMAND_TO_PACKAGE[command];
-  if (!packageName) return false;
-  if (await isCommandInPackageJson(command)) {
-    relinka("verbose", `[dlerPreBuild] Package "${packageName}" found in package.json`);
-    return true;
-  }
-  relinka(
-    "warn",
-    `[dlerPreBuild] Package "${packageName}" not found in package.json. Consider installing it as a dependency.`
-  );
-  return await lookpath(command) !== void 0;
-}
-export async function executeCommand(command) {
-  const [firstWord, ...rest] = command.split(" ").filter(Boolean);
-  if (!firstWord) return;
-  const pkgManagers = ["bun", "yarn", "pnpm", "npm"];
-  const isPkgManager = pkgManagers.includes(firstWord);
-  const cmd = isPkgManager ? rest[0] : firstWord;
-  const args = isPkgManager ? rest.slice(1) : rest;
-  if (!cmd) return;
-  const packageName = COMMAND_TO_PACKAGE[cmd];
-  if (packageName && await isCommandInPackageJson(cmd)) {
-    const pkgManager = isPkgManager ? firstWord : await getPackageManager();
-    if (process.versions.bun) {
-      await $`${pkgManager} ${cmd} ${args.join(" ")}`;
-    } else {
-      await execa(pkgManager, [cmd, ...args], { stdio: "inherit" });
-    }
-    return;
-  }
-  if (process.versions.bun) {
-    await $`${cmd} ${args.join(" ")}`;
-  } else {
-    await execa(cmd, args, { stdio: "inherit" });
-  }
-}
-export async function directoryExists(dirPath) {
-  try {
-    return (await fs.stat(dirPath)).isDirectory();
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-}
-export async function executeDlerHooks(hooks, phase) {
-  if (!hooks.length) return;
-  relinka("verbose", `[dlerPreBuild] Running ${phase} hooks...`);
-  for (const hook of hooks) {
-    try {
-      await hook();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      relinka("error", `[dlerPreBuild] Error in ${phase} hook: ${message}`);
-      throw error;
-    }
-  }
-}

package/bin/impl/build/prebuild.d.ts

@@ -1,2 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-export declare function dlerPreBuild(config: ReliverseConfig): Promise<void>;

package/bin/impl/build/prebuild.js

@@ -1,108 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-import { PROJECT_ROOT } from "../config/constants.js";
-import { executeCommand, executeDlerHooks, isCommandAvailable } from "./ppb-utils.js";
-const createToolRunner = () => ({
-  tsc: {
-    name: "TypeScript compiler",
-    run: () => executeCommand("tsc --noEmit")
-  },
-  eslint: {
-    name: "ESLint",
-    run: () => executeCommand("eslint --cache --fix .")
-  },
-  biome: {
-    name: "Biome",
-    run: () => executeCommand("biome check --fix --unsafe .")
-  },
-  knip: {
-    name: "Knip",
-    run: () => executeCommand("knip")
-  },
-  "dler-check": {
-    name: "Dler Check",
-    async run() {
-    }
-  }
-});
-async function copyFilesToTempDir(srcDir, tempDir, extensions, excludeDir) {
-  try {
-    await fs.ensureDir(tempDir);
-    const files = await glob("**/*", {
-      cwd: srcDir,
-      ignore: [`**/${excludeDir}/**`],
-      onlyFiles: true
-    });
-    for (const file of files) {
-      const ext = path.extname(file).slice(1);
-      if (extensions.includes(ext)) {
-        const srcPath = path.join(srcDir, file);
-        const destPath = path.join(tempDir, file);
-        await fs.ensureDir(path.dirname(destPath));
-        await fs.copy(srcPath, destPath);
-      }
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      `Error copying files to temp directory: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-export async function dlerPreBuild(config) {
-  relinka("verbose", "\u2014 \u2014 \u2014 dlerPreBuild \u2014 \u2014 \u2014");
-  await executeDlerHooks(config?.hooksBeforeBuild ?? [], "pre-build");
-  const tempDirs = {
-    npm: path.join(PROJECT_ROOT, "dist-tmp", "tmp-npm"),
-    jsr: path.join(PROJECT_ROOT, "dist-tmp", "tmp-jsr"),
-    libs: path.join(PROJECT_ROOT, "dist-tmp", "tmp-libs")
-  };
-  for (const dir of Object.values(tempDirs)) {
-    await fs.remove(dir);
-  }
-  if (config.commonPubRegistry === "npm" || config.commonPubRegistry === "npm-jsr") {
-    await copyFilesToTempDir(
-      path.join(PROJECT_ROOT, config.coreEntrySrcDir),
-      tempDirs.npm,
-      config.buildPreExtensions,
-      config.buildTemplatesDir
-    );
-  }
-  if (config.commonPubRegistry === "jsr" || config.commonPubRegistry === "npm-jsr") {
-    await copyFilesToTempDir(
-      path.join(PROJECT_ROOT, config.coreEntrySrcDir),
-      tempDirs.jsr,
-      config.buildPreExtensions,
-      config.buildTemplatesDir
-    );
-  }
-  if (config.libsActMode === "libs-only" || config.libsActMode === "main-and-libs") {
-    await copyFilesToTempDir(
-      path.join(PROJECT_ROOT, config.libsDirSrc),
-      tempDirs.libs,
-      config.buildPreExtensions,
-      config.buildTemplatesDir
-    );
-  }
-  if (!config?.runBeforeBuild?.length) return;
-  const tools = createToolRunner();
-  const availableTools = await Promise.all(
-    config.runBeforeBuild.map(async (toolName) => {
-      const tool = tools[toolName];
-      if (!tool) return null;
-      if (toolName === "dler-check") {
-        return { toolName, ...tool };
-      }
-      const isAvailable = await isCommandAvailable(toolName);
-      return isAvailable ? { toolName, ...tool } : null;
-    })
-  );
-  const commandsToRun = availableTools.filter(Boolean);
-  for (const { name, run } of commandsToRun) {
-    relinka("verbose", `Running ${name}...`);
-    await run();
-  }
-}

package/bin/impl/build/providers/auto.d.ts

@@ -1,3 +0,0 @@
-import type { BuildPreset } from "../../types/mod.js";
-export declare function definePreset(preset: BuildPreset): BuildPreset;
-export declare const autoPreset: BuildPreset;