@reliverse/dler 1.2.0

package/bin/cli/args/tools/index.js

@@ -0,0 +1,81 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import path from "pathe";
+import { printUsage, useAggregator } from "./tools-impl.js";
+const TOOLS = ["agg"];
+export default defineCommand({
+  meta: {
+    name: "tools",
+    version: "1.2.0",
+    description: `Runs selected dler tool. Available tools: ${TOOLS.join(", ")}`
+  },
+  args: {
+    dev: {
+      description: "Run in development mode",
+      type: "boolean"
+    },
+    import: {
+      description: "If true, produce import lines instead of export lines",
+      type: "boolean"
+    },
+    input: {
+      description: "Directory containing .ts/.js files",
+      type: "string"
+    },
+    named: {
+      description: "Parse each file for named exports (function/class/const/let)",
+      type: "boolean"
+    },
+    out: {
+      description: "Output aggregator file path",
+      type: "string"
+    },
+    recursive: {
+      description: "Recursively scan subdirectories (default false)",
+      type: "boolean"
+    },
+    strip: {
+      description: "Remove this path prefix from final imports/exports",
+      type: "string"
+    },
+    tool: {
+      description: "Tool to run",
+      type: "string"
+    }
+  },
+  async run({ args }) {
+    const isDev = args.dev;
+    if (!args.tool) {
+      relinka("error", "Missing required param: --tool <toolName>");
+      printUsage(isDev);
+      process.exit(1);
+    }
+    if (!TOOLS.includes(args.tool)) {
+      relinka("error", `Error: Invalid tool: ${args.tool}`);
+      relinka("info", `Available tools: ${TOOLS.join(", ")}`);
+      printUsage(isDev);
+      process.exit(1);
+    }
+    if (args.tool === "agg") {
+      if (!args.input) {
+        relinka("error", "Missing required param: --input <directory>");
+        printUsage(isDev);
+        process.exit(1);
+      }
+      if (!args.out) {
+        relinka("error", "Missing required param: --out <fileName>");
+        printUsage(isDev);
+        process.exit(1);
+      }
+      await useAggregator({
+        inputDir: path.resolve(args.input),
+        isRecursive: !!args.recursive,
+        outFile: path.resolve(args.out),
+        stripPrefix: args.strip ? path.resolve(args.strip) : "",
+        useImport: !!args.import,
+        useNamed: !!args.named
+      });
+    }
+    process.exit(0);
+  }
+});

package/bin/cli/args/tools/tools-impl.js

@@ -0,0 +1,296 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import MagicString from "magic-string";
+import path from "pathe";
+const AGGREGATOR_START = "// AUTO-GENERATED AGGREGATOR START";
+const AGGREGATOR_END = "// AUTO-GENERATED AGGREGATOR END";
+export async function useAggregator({
+  inputDir,
+  isRecursive,
+  outFile,
+  stripPrefix,
+  useImport,
+  useNamed,
+  ignoreDirs = ["node_modules", ".git"],
+  sortLines = false,
+  headerComment = "",
+  verbose = false,
+  includeInternal = false,
+  internalMarker = "#",
+  overrideFile = false
+}) {
+  try {
+    const st = await fs.stat(inputDir).catch(() => null);
+    if (!st?.isDirectory()) {
+      relinka("error", `Error: --input is not a valid directory: ${inputDir}`);
+      process.exit(1);
+    }
+    const exts = [".ts", ".js"];
+    if (verbose)
+      relinka(
+        "info",
+        `Scanning directory ${inputDir} for files with extensions: ${exts.join(
+          ", "
+        )}`
+      );
+    const filePaths = await collectFiles(
+      inputDir,
+      exts,
+      isRecursive,
+      ignoreDirs,
+      verbose,
+      includeInternal,
+      internalMarker
+    );
+    if (!filePaths.length) {
+      relinka("warn", `No matching .ts/.js files found in ${inputDir}`);
+    }
+    const usedIdentifiers = /* @__PURE__ */ new Set();
+    const aggregatorLinesArrays = await Promise.all(
+      filePaths.map(
+        (fp) => generateAggregatorLines(
+          fp,
+          inputDir,
+          stripPrefix,
+          useImport,
+          useNamed,
+          usedIdentifiers
+        )
+      )
+    );
+    const allLines = aggregatorLinesArrays.flat();
+    if (sortLines) {
+      allLines.sort();
+      if (verbose) relinka("info", "Sorted aggregator lines alphabetically.");
+    }
+    if (outFile.startsWith(inputDir)) {
+      relinka(
+        "warn",
+        `Warning: The output file is inside (or overlaps with) the input directory.
+Might re-import (or re-export) itself.
+   input: ${inputDir}
+   out: ${outFile}
+`
+      );
+    }
+    const aggregatorContent = allLines.join("\n");
+    const aggregatorBlock = `${headerComment ? `${headerComment}
+` : ""}${AGGREGATOR_START}
+${aggregatorContent}
+${AGGREGATOR_END}
+`;
+    let finalText;
+    if (overrideFile) {
+      finalText = aggregatorBlock;
+      if (verbose) {
+        relinka("info", "Override mode: rewriting entire file.");
+      }
+    } else {
+      let existingContent = "";
+      try {
+        existingContent = await fs.readFile(outFile, "utf8");
+      } catch {
+        if (verbose)
+          relinka("info", "Aggregator file does not exist. Creating new one.");
+      }
+      if (existingContent?.includes(AGGREGATOR_START) && existingContent.includes(AGGREGATOR_END)) {
+        if (verbose) {
+          relinka(
+            "info",
+            "Existing aggregator block found. Updating auto-generated section."
+          );
+        }
+        const s = new MagicString(existingContent);
+        const startIdx = existingContent.indexOf(AGGREGATOR_START);
+        const endIdx = existingContent.indexOf(AGGREGATOR_END) + AGGREGATOR_END.length;
+        s.update(startIdx, endIdx, aggregatorBlock.trim());
+        finalText = s.toString();
+      } else {
+        if (existingContent) {
+          if (verbose)
+            relinka(
+              "info",
+              "No aggregator block found. Appending auto-generated section."
+            );
+          finalText = `${existingContent.trim()}
+
+${aggregatorBlock}`;
+        } else {
+          finalText = aggregatorBlock;
+        }
+      }
+    }
+    await fs.ensureFile(outFile);
+    await fs.writeFile(outFile, finalText, "utf8");
+    relinka(
+      "success",
+      `Aggregator done: processed ${allLines.length} lines in:
+  ${outFile}`
+    );
+  } catch (error) {
+    relinka("error", `Aggregator failed: ${error}`);
+    process.exit(1);
+  }
+}
+function buildPathRelative(filePath, inputDir, stripPrefix) {
+  let resolved = path.resolve(filePath);
+  const resolvedStrip = stripPrefix ? path.resolve(stripPrefix) : "";
+  if (resolvedStrip && resolved.startsWith(resolvedStrip)) {
+    resolved = resolved.slice(resolvedStrip.length);
+  } else {
+    resolved = path.relative(path.resolve(inputDir), resolved);
+  }
+  while (resolved.startsWith(path.sep)) {
+    resolved = resolved.slice(1);
+  }
+  resolved = resolved.replace(/\\/g, "/");
+  if (resolved.toLowerCase().endsWith(".ts")) {
+    resolved = `${resolved.slice(0, -3)}.js`;
+  }
+  if (!resolved.startsWith("./") && !resolved.startsWith("../")) {
+    resolved = `./${resolved}`;
+  }
+  return resolved;
+}
+async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker) {
+  const found = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (ignoreDirs.includes(entry.name)) {
+        if (verbose) {
+          relinka("info", `Skipping ignored directory: ${fullPath}`);
+        }
+        continue;
+      }
+      if (recursive) {
+        const sub = await collectFiles(
+          fullPath,
+          exts,
+          recursive,
+          ignoreDirs,
+          verbose,
+          includeInternal,
+          internalMarker
+        );
+        found.push(...sub);
+      }
+    } else if (entry.isFile()) {
+      if (!includeInternal && path.basename(fullPath).startsWith(internalMarker)) {
+        if (verbose) {
+          relinka("info", `Skipping internal file: ${fullPath}`);
+        }
+        continue;
+      }
+      if (exts.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
+        if (verbose) {
+          relinka("info", `Found file: ${fullPath}`);
+        }
+        found.push(fullPath);
+      }
+    }
+  }
+  return found;
+}
+async function generateAggregatorLines(filePath, inputDir, stripPrefix, useImport, useNamed, usedIdentifiers) {
+  const importPath = buildPathRelative(filePath, inputDir, stripPrefix);
+  if (!useNamed) {
+    if (useImport) {
+      let ident = guessStarImportIdentifier(filePath);
+      if (usedIdentifiers) {
+        let uniqueIdent = ident;
+        let counter = 1;
+        while (usedIdentifiers.has(uniqueIdent)) {
+          uniqueIdent = `${ident}_${counter}`;
+          counter++;
+        }
+        usedIdentifiers.add(uniqueIdent);
+        ident = uniqueIdent;
+      }
+      return [`import * as ${ident} from "${importPath}";`];
+    }
+    return [`export * from "${importPath}";`];
+  }
+  const { typeNames, valueNames } = await getNamedExports(filePath);
+  if (!typeNames.length && !valueNames.length) {
+    return [];
+  }
+  if (useImport) {
+    const lines2 = [];
+    if (typeNames.length > 0) {
+      lines2.push(
+        `import type { ${typeNames.join(", ")} } from "${importPath}";`
+      );
+    }
+    if (valueNames.length > 0) {
+      lines2.push(`import { ${valueNames.join(", ")} } from "${importPath}";`);
+    }
+    return lines2;
+  }
+  const lines = [];
+  if (typeNames.length > 0) {
+    lines.push(`export type { ${typeNames.join(", ")} } from "${importPath}";`);
+  }
+  if (valueNames.length > 0) {
+    lines.push(`export { ${valueNames.join(", ")} } from "${importPath}";`);
+  }
+  return lines;
+}
+async function getNamedExports(filePath) {
+  try {
+    const code = await fs.readFile(filePath, "utf-8");
+    const pattern = /^export\s+(?:async\s+)?(function|const|class|let|type|interface)\s+([A-Za-z0-9_$]+)/gm;
+    const typeNamesSet = /* @__PURE__ */ new Set();
+    const valueNamesSet = /* @__PURE__ */ new Set();
+    let match;
+    while (true) {
+      match = pattern.exec(code);
+      if (match === null) break;
+      const keyword = match[1];
+      const name = match[2];
+      if (keyword && name) {
+        if (keyword === "type" || keyword === "interface") {
+          typeNamesSet.add(name);
+        } else {
+          valueNamesSet.add(name);
+        }
+      }
+    }
+    return {
+      typeNames: Array.from(typeNamesSet),
+      valueNames: Array.from(valueNamesSet)
+    };
+  } catch (error) {
+    relinka("error", `Error reading file ${filePath}: ${error}`);
+    return { typeNames: [], valueNames: [] };
+  }
+}
+function guessStarImportIdentifier(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  let identifier = base.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(identifier)) {
+    identifier = `_${identifier}`;
+  }
+  return identifier || "file";
+}
+export function printUsage(isDev) {
+  relinka("info", "====================");
+  relinka("info", "TOOLS USAGE EXAMPLES");
+  relinka("info", "====================");
+  relinka(
+    "info",
+    `${isDev ? "bun dev:agg" : "dler tools"} --tool agg --input <dir> --out <file> [options]`
+  );
+  if (isDev) {
+    relinka(
+      "info",
+      "bun dev:tools agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-main.ts --recursive --named --strip src/libs/sdk"
+    );
+  } else {
+    relinka(
+      "info",
+      "dler tools --tool agg --input src/libs --out aggregator.ts --recursive --named"
+    );
+  }
+}

package/bin/cli.js

@@ -0,0 +1,111 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+import { processLibraryFlow } from "./libs/sdk/sdk-impl/library-flow.js";
+import { processRegularFlow } from "./libs/sdk/sdk-impl/regular-flow.js";
+import { bumpHandler } from "./libs/sdk/sdk-impl/utils/utils-bump.js";
+import { removeDistFolders } from "./libs/sdk/sdk-impl/utils/utils-clean.js";
+import { PROJECT_ROOT } from "./libs/sdk/sdk-impl/utils/utils-consts.js";
+import { handleDlerError } from "./libs/sdk/sdk-impl/utils/utils-error.js";
+import { finalizeBuild } from "./libs/sdk/sdk-impl/utils/utils-info.js";
+import { createPerfTimer } from "./libs/sdk/sdk-impl/utils/utils-perf.js";
+import { loadConfig } from "./load.js";
+export async function dler(isDev) {
+  const timer = createPerfTimer();
+  try {
+    const config = await loadConfig();
+    if (isDev) {
+      config.commonPubPause = true;
+      config.bumpDisable = true;
+      relinka(
+        "info",
+        "Development mode: Publishing paused and version bumping disabled."
+      );
+    }
+    if (config.logsFreshFile) {
+      await fs.remove(path.join(PROJECT_ROOT, config.logsFileName));
+    }
+    await removeDistFolders(
+      config.distNpmDirName,
+      config.distJsrDirName,
+      config.libsDirDist,
+      config.libsList
+    );
+    if (!config.bumpDisable) {
+      await bumpHandler(
+        config.bumpMode,
+        config.bumpDisable,
+        config.commonPubPause,
+        config.bumpFilter
+      );
+    }
+    await processRegularFlow(
+      timer,
+      isDev,
+      config.coreIsCLI,
+      config.libsActMode,
+      config.commonPubRegistry,
+      config.coreEntrySrcDir,
+      config.distNpmDirName,
+      config.distNpmBuilder,
+      config.coreEntryFile,
+      config.distJsrDryRun,
+      config.distJsrFailOnWarn,
+      config.commonPubPause,
+      config.distJsrDirName,
+      config.distJsrBuilder,
+      config.transpileTarget,
+      config.transpileFormat,
+      config.transpileSplitting,
+      config.transpileMinify,
+      config.transpileSourcemap,
+      config.transpilePublicPath,
+      config.distJsrAllowDirty,
+      config.distJsrSlowTypes,
+      config.distNpmOutFilesExt,
+      config.rmDepsMode,
+      config.transpileStub,
+      config.transpileWatch,
+      config.distJsrGenTsconfig,
+      config.coreDeclarations
+    );
+    await processLibraryFlow(
+      timer,
+      isDev,
+      config.libsActMode,
+      config.libsList,
+      config.distJsrDryRun,
+      config.distJsrFailOnWarn,
+      config.libsDirDist,
+      config.libsDirSrc,
+      config.commonPubPause,
+      config.commonPubRegistry,
+      config.distNpmOutFilesExt,
+      config.distNpmBuilder,
+      config.coreEntrySrcDir,
+      config.rmDepsMode,
+      config.rmDepsPatterns,
+      config.transpileEsbuild,
+      config.transpileTarget,
+      config.transpileFormat,
+      config.transpileSplitting,
+      config.transpileSourcemap,
+      config.transpilePublicPath,
+      config.distJsrBuilder,
+      config.transpileStub,
+      config.transpileWatch,
+      config.distJsrOutFilesExt
+    );
+    await finalizeBuild(
+      timer,
+      config.commonPubPause,
+      config.libsList,
+      config.distNpmDirName,
+      config.distJsrDirName,
+      config.libsDirDist,
+      isDev
+    );
+  } catch (error) {
+    handleDlerError(error, timer);
+  }
+}

package/bin/init.js

@@ -0,0 +1,157 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+import { DEFAULT_CONFIG } from "./libs/cfg/cfg-default.js";
+const CONFIG_FILENAME = ".config/dler.ts";
+export async function initDlerConfig(isDev) {
+  const configPath = path.resolve(process.cwd(), CONFIG_FILENAME);
+  const configExists = await fs.pathExists(configPath);
+  if (configExists) {
+    return;
+  }
+  try {
+    const configContent = generateConfig(isDev);
+    await fs.outputFile(configPath, configContent, "utf-8");
+    relinka("success", `Config was created at ${configPath}`);
+    relinka("info", "Edit this file to customize build and publish settings");
+    if (!isDev) {
+      relinka("info", "Please note: commonPubPause is set to true by default");
+      relinka("info", "When you're ready, run `dler` to build and publish");
+    } else {
+      relinka("info", "When you're ready, run `bun pub` to build and publish");
+    }
+    process.exit(0);
+  } catch (error) {
+    relinka(
+      "error",
+      `Error creating configuration file: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}
+function generateConfig(isDev) {
+  const importDefineConfigStatement = isDev ? `import { defineConfig } from "../src/libs/cfg/cfg-main.js";` : `import { defineConfig } from "@reliverse/dler-cfg";`;
+  const verboseValue = getValue(isDev, true, DEFAULT_CONFIG.commonVerbose);
+  const isCLIValue = getValue(isDev, true, DEFAULT_CONFIG.coreIsCLI);
+  const registryValue = getValue(
+    isDev,
+    "npm-jsr",
+    DEFAULT_CONFIG.commonPubRegistry
+  );
+  const pausePublishValue = getValue(
+    isDev,
+    false,
+    DEFAULT_CONFIG.commonPubPause
+  );
+  const coreDeclarationsValue = getValue(
+    isDev,
+    false,
+    DEFAULT_CONFIG.coreDeclarations
+  );
+  const libsActModeValue = getValue(
+    isDev,
+    "main-and-libs",
+    DEFAULT_CONFIG.libsActMode
+  );
+  const libsObject = isDev ? `{
+  "@reliverse/dler-cfg": {
+    libDeclarations: true,
+    libDescription: "@reliverse/dler defineConfig",
+    libDirName: "cfg",
+    libMainFile: "cfg/cfg-main.ts",
+    libPkgKeepDeps: false,
+    libTranspileMinify: true,
+  },
+  "@reliverse/dler-sdk": {
+    libDeclarations: true,
+    libDescription: "@reliverse/dler without cli",
+    libDirName: "sdk",
+    libMainFile: "sdk/sdk-main.ts",
+    libPkgKeepDeps: true,
+    libTranspileMinify: true,
+  },
+}` : `{
+  // "@acme/cli-libName": {
+  //   libDeclarations: true,
+  //   libDescription: "@acme/cli defineConfig",
+  //   libDirName: "libName",
+  //   libMainFile: "libName/libName-main.ts",
+  //   libPkgKeepDeps: true,
+  //   libTranspileMinify: true,
+  // },
+}`;
+  const configTemplate = `${importDefineConfigStatement}
+
+/**
+ * Reliverse Bundler Configuration
+ * Hover over a field to see more details
+ * @see https://github.com/reliverse/dler
+ */
+export default defineConfig({
+  // Bump configuration
+  bumpDisable: ${DEFAULT_CONFIG.bumpDisable},
+  bumpFilter: ${JSON.stringify(DEFAULT_CONFIG.bumpFilter)},
+  bumpMode: "${DEFAULT_CONFIG.bumpMode}",
+  
+  // Common configuration
+  commonPubPause: ${pausePublishValue},
+  commonPubRegistry: "${registryValue}",
+  commonVerbose: ${verboseValue},
+
+  // Core configuration
+  coreDeclarations: ${coreDeclarationsValue},
+  coreEntryFile: "${DEFAULT_CONFIG.coreEntryFile}",
+  coreEntrySrcDir: "${DEFAULT_CONFIG.coreEntrySrcDir}",
+  coreIsCLI: ${isCLIValue},
+
+  // JSR-only config
+  distJsrAllowDirty: ${DEFAULT_CONFIG.distJsrAllowDirty},
+  distJsrBuilder: "${DEFAULT_CONFIG.distJsrBuilder}",
+  distJsrCopyRootFiles: ${JSON.stringify(DEFAULT_CONFIG.distJsrCopyRootFiles)},
+  distJsrDirName: "${DEFAULT_CONFIG.distJsrDirName}",
+  distJsrDryRun: ${DEFAULT_CONFIG.distJsrDryRun},
+  distJsrFailOnWarn: ${DEFAULT_CONFIG.distJsrFailOnWarn},
+  distJsrGenTsconfig: ${DEFAULT_CONFIG.distJsrGenTsconfig},
+  distJsrOutFilesExt: "${DEFAULT_CONFIG.distJsrOutFilesExt}",
+  distJsrSlowTypes: ${DEFAULT_CONFIG.distJsrSlowTypes},
+
+  // NPM-only config
+  distNpmBuilder: "${DEFAULT_CONFIG.distNpmBuilder}",
+  distNpmCopyRootFiles: ${JSON.stringify(DEFAULT_CONFIG.distNpmCopyRootFiles)},
+  distNpmDirName: "${DEFAULT_CONFIG.distNpmDirName}",
+  distNpmOutFilesExt: "${DEFAULT_CONFIG.distNpmOutFilesExt}",
+
+  // Libraries Dler Plugin
+  // Publish specific dirs as separate packages
+  // This feature is experimental at the moment
+  // Please commit your changes before using it
+  libsActMode: "${libsActModeValue}",
+  libsDirDist: "${DEFAULT_CONFIG.libsDirDist}",
+  libsDirSrc: "${DEFAULT_CONFIG.libsDirSrc}",
+  libsList: ${libsObject},
+
+  // Logger setup
+  logsFileName: "${DEFAULT_CONFIG.logsFileName}",
+  logsFreshFile: ${DEFAULT_CONFIG.logsFreshFile},
+
+  // Dependency filtering
+  rmDepsMode: "${DEFAULT_CONFIG.rmDepsMode}",
+  rmDepsPatterns: ${JSON.stringify(DEFAULT_CONFIG.rmDepsPatterns)},
+
+  // Build setup
+  transpileEsbuild: "${DEFAULT_CONFIG.transpileEsbuild}",
+  transpileFormat: "${DEFAULT_CONFIG.transpileFormat}",
+  transpileMinify: ${DEFAULT_CONFIG.transpileMinify},
+  transpilePublicPath: "${DEFAULT_CONFIG.transpilePublicPath}",
+  transpileSourcemap: "${DEFAULT_CONFIG.transpileSourcemap}",
+  transpileSplitting: ${DEFAULT_CONFIG.transpileSplitting},
+  transpileStub: ${DEFAULT_CONFIG.transpileStub},
+  transpileTarget: "${DEFAULT_CONFIG.transpileTarget}",
+  transpileWatch: ${DEFAULT_CONFIG.transpileWatch},
+});
+`;
+  return configTemplate;
+}
+function getValue(isDev, devValue, prodValue) {
+  return isDev ? devValue : prodValue;
+}

package/bin/libs/cfg/cfg-default.js

@@ -0,0 +1,50 @@
+export const DEFAULT_CONFIG = {
+  bumpDisable: false,
+  bumpFilter: ["package.json", ".config/rse.ts"],
+  bumpMode: "autoPatch",
+  commonPubPause: true,
+  commonPubRegistry: "npm",
+  commonVerbose: false,
+  coreDeclarations: true,
+  coreEntryFile: "main.ts",
+  coreEntrySrcDir: "src",
+  coreIsCLI: false,
+  distJsrAllowDirty: true,
+  distJsrBuilder: "jsr",
+  distJsrCopyRootFiles: ["README.md", "LICENSE"],
+  distJsrDirName: "dist-jsr",
+  distJsrDryRun: false,
+  distJsrFailOnWarn: false,
+  distJsrGenTsconfig: false,
+  distJsrOutFilesExt: "ts",
+  distJsrSlowTypes: true,
+  distNpmBuilder: "mkdist",
+  distNpmCopyRootFiles: ["README.md", "LICENSE"],
+  distNpmDirName: "dist-npm",
+  distNpmOutFilesExt: "js",
+  libsActMode: "main-project-only",
+  libsDirDist: "dist-libs",
+  libsDirSrc: "src/libs",
+  libsList: {},
+  logsFileName: "logs/relinka.log",
+  logsFreshFile: true,
+  rmDepsMode: "patterns-and-devdeps",
+  rmDepsPatterns: [
+    "@types",
+    "biome",
+    "eslint",
+    "knip",
+    "prettier",
+    "typescript",
+    "@reliverse/config"
+  ],
+  transpileEsbuild: "es2023",
+  transpileFormat: "esm",
+  transpileMinify: true,
+  transpilePublicPath: "/",
+  transpileSourcemap: "none",
+  transpileSplitting: false,
+  transpileStub: false,
+  transpileTarget: "node",
+  transpileWatch: false
+};

package/bin/libs/cfg/cfg-main.js

@@ -0,0 +1 @@
+export { defineConfig } from "./cfg-mod.js";

package/bin/libs/cfg/cfg-mod.js

@@ -0,0 +1,4 @@
+import { DEFAULT_CONFIG } from "./cfg-default.js";
+export const defineConfig = (userConfig = {}) => {
+  return { ...DEFAULT_CONFIG, ...userConfig };
+};