@reliverse/dler 1.7.73 → 1.7.74

package/bin/app/agg/impl.d.ts

@@ -1,39 +0,0 @@
-/**
- * Aggregator supporting:
- * - --import or default export,
- * - star or named exports,
- * - separate "type" vs "value" for both import and export.
- *
- * Options:
- * - Option to ignore specific directories (default: node_modules, .git)
- * - Option to sort aggregated lines alphabetically.
- * - Option to add a header comment in the aggregator output.
- * - Option to enable verbose logging.
- * - Deduplicates overloaded export names.
- * - Skips files whose basenames start with an internal marker (default: "#")
- *   unless includeInternal is true or an alternative marker is provided.
- * - By default, updates only the auto-generated block in the aggregator file,
- *   leaving any other content intact. Pass `overrideFile: true` to rewrite the entire file.
- */
-export declare function useAggregator({ inputDir, isRecursive, outFile, stripPrefix, useImport, useNamed, ignoreDirs, sortLines, headerComment, verbose, includeInternal, internalMarker, overrideFile, fileExtensions, separateTypesFile, typesOutFile, }: {
-    inputDir: string;
-    isRecursive: boolean;
-    outFile: string;
-    stripPrefix: string;
-    useImport: boolean;
-    useNamed: boolean;
-    ignoreDirs?: string[];
-    sortLines?: boolean;
-    headerComment?: string;
-    verbose?: boolean;
-    includeInternal?: boolean;
-    internalMarker?: string;
-    overrideFile?: boolean;
-    fileExtensions?: string[];
-    separateTypesFile?: boolean;
-    typesOutFile?: string;
-}): Promise<void>;
-/**
- * Prints usage examples based on whether dev mode or not.
- */
-export declare function printUsage(isDev?: boolean): void;

package/bin/app/agg/impl.js

@@ -1,341 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-const AGGREGATOR_START = "// AUTO-GENERATED AGGREGATOR START (via `dler agg`)";
-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,
-  fileExtensions = [".ts", ".js", ".mts", ".cts", ".mjs", ".cjs"],
-  separateTypesFile = false,
-  typesOutFile
-}) {
-  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 outDir = path.dirname(outFile);
-    try {
-      await fs.ensureDir(outDir);
-    } catch (error) {
-      relinka("error", `Error: Cannot create output directory: ${outDir}
-${error}`);
-      process.exit(1);
-    }
-    if (separateTypesFile && typesOutFile) {
-      const typesOutDir = path.dirname(typesOutFile);
-      try {
-        await fs.ensureDir(typesOutDir);
-      } catch (error) {
-        relinka("error", `Error: Cannot create types output directory: ${typesOutDir}
-${error}`);
-        process.exit(1);
-      }
-    }
-    const outExt = path.extname(outFile).toLowerCase();
-    if (!fileExtensions.includes(outExt)) {
-      relinka(
-        "warn",
-        `Warning: Output file extension (${outExt}) doesn't match any of the input extensions: ${fileExtensions.join(", ")}`
-      );
-    }
-    if (stripPrefix) {
-      const stripSt = await fs.stat(stripPrefix).catch(() => null);
-      if (!stripSt?.isDirectory()) {
-        relinka("error", `Error: --strip is not a valid directory: ${stripPrefix}`);
-        process.exit(1);
-      }
-    }
-    if (verbose)
-      relinka(
-        "log",
-        `Scanning directory ${inputDir} for files with extensions: ${fileExtensions.join(", ")}`
-      );
-    const filePaths = await collectFiles(
-      inputDir,
-      fileExtensions,
-      isRecursive,
-      ignoreDirs,
-      verbose,
-      includeInternal,
-      internalMarker,
-      outFile
-    );
-    if (!filePaths.length) {
-      relinka(
-        "warn",
-        `No matching files found in ${inputDir} with extensions: ${fileExtensions.join(", ")}`
-      );
-      if (!overrideFile) {
-        relinka("warn", "No changes will be made to the output file.");
-        return;
-      }
-    }
-    const usedIdentifiers = /* @__PURE__ */ new Set();
-    const aggregatorLinesArrays = await Promise.all(
-      filePaths.map(
-        (fp) => generateAggregatorLines(
-          fp,
-          inputDir,
-          stripPrefix,
-          useImport,
-          useNamed,
-          usedIdentifiers
-        ).catch((error) => {
-          relinka("error", `Error processing file ${fp}: ${error}`);
-          return [];
-        })
-      )
-    );
-    const allLines = aggregatorLinesArrays.flat();
-    const typeLines = [];
-    const valueLines = [];
-    for (const line of allLines) {
-      if (line.includes("type {")) {
-        typeLines.push(line);
-      } else {
-        valueLines.push(line);
-      }
-    }
-    if (sortLines) {
-      typeLines.sort();
-      valueLines.sort();
-      if (verbose) relinka("log", "Sorted aggregator lines alphabetically.");
-    }
-    const buildAggregatorBlock = (lines) => `${headerComment ? `${headerComment}
-` : ""}${AGGREGATOR_START}
-${lines.join("\n")}
-${AGGREGATOR_END}
-`;
-    if (separateTypesFile && typesOutFile) {
-      const typeBlock = buildAggregatorBlock(typeLines);
-      await fs.ensureFile(typesOutFile);
-      await fs.writeFile(typesOutFile, typeBlock, "utf8");
-      const valueBlock = buildAggregatorBlock([
-        ...valueLines,
-        `export * from "${path.relative(path.dirname(outFile), typesOutFile).replace(/\\/g, "/")}";`
-      ]);
-      await fs.ensureFile(outFile);
-      await fs.writeFile(outFile, valueBlock, "utf8");
-      relinka(
-        "success",
-        `Aggregator done: processed ${typeLines.length} type lines in: ${typesOutFile} and ${valueLines.length} value lines in: ${outFile}`
-      );
-    } else {
-      const aggregatorBlock = buildAggregatorBlock(allLines);
-      await fs.ensureFile(outFile);
-      await fs.writeFile(outFile, aggregatorBlock, "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}`;
-  }
-  resolved = resolved.replace(/\/+/g, "/");
-  return resolved;
-}
-async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker, outFile) {
-  const found = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (outFile && path.resolve(fullPath) === path.resolve(outFile)) {
-      if (verbose) {
-        relinka("log", `Skipping output file: ${fullPath}`);
-      }
-      continue;
-    }
-    if (entry.isDirectory()) {
-      if (ignoreDirs.includes(entry.name)) {
-        if (verbose) {
-          relinka("log", `Skipping ignored directory: ${fullPath}`);
-        }
-        continue;
-      }
-      if (recursive) {
-        const sub = await collectFiles(
-          fullPath,
-          exts,
-          recursive,
-          ignoreDirs,
-          verbose,
-          includeInternal,
-          internalMarker,
-          outFile
-        );
-        found.push(...sub);
-      }
-    } else if (entry.isFile()) {
-      if (!includeInternal && path.basename(fullPath).startsWith(internalMarker)) {
-        if (verbose) {
-          relinka("log", `Skipping internal file: ${fullPath}`);
-        }
-        continue;
-      }
-      if (exts.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
-        if (verbose) {
-          relinka("log", `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, "utf8");
-    const typeNamesSet = /* @__PURE__ */ new Set();
-    const valueNamesSet = /* @__PURE__ */ new Set();
-    const patterns = [
-      // Regular exports and default exports
-      /^export\s+(?:default\s+)?(?:async\s+)?(function|const|class|let|var|type|interface|enum)\s+([A-Za-z0-9_$]+)/gm,
-      // Named exports and re-exports
-      /^export\s*{([^}]+)}(?:\s+from\s+['"][^'"]+['"])?/gm,
-      // Export assignments
-      /^export\s*=\s*([A-Za-z0-9_$]+)/gm
-    ];
-    for (const pattern of patterns) {
-      let match;
-      while (true) {
-        match = pattern.exec(code);
-        if (!match) break;
-        const matchGroups = match;
-        if (pattern.source.includes("{([^}]+)}") && matchGroups[1]) {
-          const exports = (matchGroups[1] ?? "").split(",").map(
-            (e) => e?.trim()?.split(/\s+as\s+/)?.[0]?.trim() ?? ""
-          );
-          for (const exp of exports) {
-            const name = exp.replace(/^type\s+/, "");
-            if (exp.startsWith("type ")) {
-              typeNamesSet.add(name);
-            } else {
-              valueNamesSet.add(name);
-            }
-          }
-        } else if (pattern.source.includes("=\\s*([A-Za-z0-9_$]+)") && matchGroups[1]) {
-          valueNamesSet.add(matchGroups[1]);
-        } else {
-          const keyword = matchGroups[1];
-          const name = matchGroups[2];
-          if (keyword && name) {
-            if (keyword === "type" || keyword === "interface" || keyword === "enum") {
-              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("log", "====================");
-  relinka("log", "TOOLS USAGE EXAMPLES");
-  relinka("log", "====================");
-  relinka(
-    "log",
-    `${isDev ? "bun dev:agg" : "dler tools"} --tool agg --input <dir> --out <file> [options]`
-  );
-  if (isDev) {
-    relinka(
-      "log",
-      "bun dev:tools agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-mod.ts --recursive --named --strip src/libs/sdk"
-    );
-  } else {
-    relinka(
-      "log",
-      "dler tools --tool agg --input src/libs --out aggregator.ts --recursive --named"
-    );
-  }
-}

package/bin/app/agg/run.d.ts

@@ -1 +0,0 @@
-export declare function promptAggCommand(): Promise<void>;

package/bin/app/agg/run.js

@@ -1,136 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { selectPrompt, runCmd, confirmPrompt, inputPrompt } from "@reliverse/rempts";
-import { getAggCmd } from "../cmds.js";
-import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-async function fileExists(filePath) {
-  return await fs.pathExists(filePath);
-}
-async function findMainEntryFile(config) {
-  const { coreEntryFile, coreEntrySrcDir } = config;
-  if (coreEntryFile && coreEntrySrcDir) {
-    const configuredPath = path.join(coreEntrySrcDir, coreEntryFile);
-    if (await fileExists(configuredPath)) {
-      return configuredPath;
-    }
-  }
-  const fallbackPatterns = [
-    path.join(coreEntrySrcDir || "src", "mod.ts"),
-    path.join(coreEntrySrcDir || "src", "index.ts"),
-    path.join(coreEntrySrcDir || "src", "mod.js"),
-    path.join(coreEntrySrcDir || "src", "index.js")
-  ];
-  for (const pattern of fallbackPatterns) {
-    if (await fileExists(pattern)) {
-      return pattern;
-    }
-  }
-  return null;
-}
-export async function promptAggCommand() {
-  const config = await getConfigDler();
-  let selectedLibName = null;
-  const mainEntryFile = await findMainEntryFile(config);
-  if (config?.libsList && Object.keys(config.libsList).length > 0) {
-    const libs = Object.entries(config.libsList).map(([name, lib]) => ({
-      value: name,
-      label: name,
-      hint: `${config.libsDirSrc}/${lib.libDirName}/${lib.libDirName}-impl`
-    }));
-    if (mainEntryFile) {
-      libs.unshift({
-        value: "main",
-        label: "Main package",
-        hint: mainEntryFile
-      });
-    }
-    libs.push({ value: "", label: "Skip selection", hint: "" });
-    selectedLibName = await selectPrompt({
-      title: "Select a package to aggregate or skip",
-      options: libs
-    });
-  } else if (mainEntryFile) {
-    const shouldUseMain = await confirmPrompt({
-      title: "Use main package for aggregation?",
-      content: `Found: ${mainEntryFile}`,
-      defaultValue: true
-    });
-    if (shouldUseMain) {
-      selectedLibName = "main";
-    }
-  }
-  let imports = false;
-  let input = "";
-  let named = true;
-  let out = "";
-  let recursive = true;
-  let strip = "";
-  let separateTypesFile = false;
-  let typesOut = "";
-  if (selectedLibName && selectedLibName !== "") {
-    if (selectedLibName === "main" && mainEntryFile) {
-      const entryDir = path.dirname(mainEntryFile);
-      input = entryDir;
-      out = mainEntryFile;
-      strip = entryDir;
-    } else {
-      const libConfig = config?.libsList?.[selectedLibName];
-      if (config && libConfig) {
-        input = `${config.libsDirSrc}/${libConfig.libDirName}/${libConfig.libDirName}-impl`;
-        out = `${config.libsDirSrc}/${libConfig.libMainFile}`;
-        strip = `${config.libsDirSrc}/${libConfig.libDirName}`;
-      }
-    }
-  }
-  if (!selectedLibName || !input) {
-    input = await inputPrompt({
-      title: "Enter the input directory",
-      defaultValue: input
-    });
-  }
-  imports = await confirmPrompt({
-    title: "Do you want to generate imports instead of exports?",
-    content: "(N generates exports)",
-    defaultValue: imports
-  });
-  named = await confirmPrompt({
-    title: imports ? "Do you want to generate named imports?" : "Do you want to generate named exports?",
-    defaultValue: named
-  });
-  if (!selectedLibName || !out) {
-    out = await inputPrompt({
-      title: "Enter the output file",
-      defaultValue: out
-    });
-  }
-  recursive = await confirmPrompt({
-    title: "Do you want to recursively scan subdirectories?",
-    defaultValue: recursive
-  });
-  if (!selectedLibName || !strip) {
-    strip = await inputPrompt({
-      title: "Enter the path to strip from the final imports/exports",
-      defaultValue: strip
-    });
-  }
-  separateTypesFile = await confirmPrompt({
-    title: "Do you want to create a separate file for type exports?",
-    defaultValue: separateTypesFile
-  });
-  if (separateTypesFile) {
-    typesOut = await inputPrompt({
-      title: "Enter the output file for types",
-      defaultValue: out.replace(/\.(ts|js)$/, ".types.$1")
-    });
-  }
-  await runCmd(await getAggCmd(), [
-    `--imports=${imports}`,
-    `--input=${input}`,
-    `--named=${named}`,
-    `--out=${out}`,
-    `--recursive=${recursive}`,
-    `--strip=${strip}`,
-    `--separateTypesFile=${separateTypesFile}`,
-    ...separateTypesFile ? [`--typesOut=${typesOut}`] : []
-  ]);
-}

package/bin/libs/cfg/cfg-impl/cfg-consts.d.ts

@@ -1,77 +0,0 @@
-import type { DlerConfig } from "./cfg-types";
-/**
- * Default configuration for the build and publish logic.
- */
-export declare const DEFAULT_CONFIG_DLER: DlerConfig;
-export declare const defineConfig: (userConfig?: Partial<DlerConfig>) => {
-    bumpDisable: boolean;
-    bumpFilter: string[];
-    bumpMode: import("./cfg-types").BumpMode;
-    bumpSet: string;
-    commonPubPause: boolean;
-    commonPubRegistry: "jsr" | "npm" | "npm-jsr";
-    commonVerbose: boolean;
-    coreDeclarations: boolean;
-    coreEntryFile: string;
-    coreEntrySrcDir: string;
-    coreBuildOutDir: string;
-    coreIsCLI: {
-        enabled: boolean;
-        scripts: Record<string, string>;
-    };
-    coreDescription: string;
-    distJsrAllowDirty: boolean;
-    distJsrBuilder: import("./cfg-types").BundlerName;
-    distJsrDirName: string;
-    distJsrDryRun: boolean;
-    distJsrFailOnWarn: boolean;
-    distJsrGenTsconfig: boolean;
-    distJsrOutFilesExt: import("./cfg-types").NpmOutExt;
-    distJsrSlowTypes: boolean;
-    distNpmBuilder: import("./cfg-types").BundlerName;
-    distNpmDirName: string;
-    distNpmOutFilesExt: import("./cfg-types").NpmOutExt;
-    libsActMode: "libs-only" | "main-and-libs" | "main-project-only";
-    libsDirDist: string;
-    libsDirSrc: string;
-    libsList: Record<string, import("./cfg-types").LibConfig>;
-    logsFileName: string;
-    logsFreshFile: boolean;
-    filterDepsPatterns: {
-        global: string[];
-        "dist-npm": string[];
-        "dist-jsr": string[];
-        "dist-libs": Record<string, {
-            npm: string[];
-            jsr: string[];
-        }>;
-    };
-    runBeforeBuild: ("tsc" | "eslint" | "biome" | "knip" | "dler-check")[];
-    runAfterBuild: "dler-check"[];
-    hooksBeforeBuild: (() => Promise<void>)[];
-    hooksAfterBuild: (() => Promise<void>)[];
-    postBuildSettings: {
-        deleteDistTmpAfterBuild: boolean;
-    };
-    transpileFailOnWarn: boolean;
-    transpileEsbuild: import("./cfg-types").Esbuild;
-    transpileFormat: import("./cfg-types").transpileFormat;
-    transpileMinify: boolean;
-    transpilePublicPath: string;
-    transpileSourcemap: import("./cfg-types").Sourcemap;
-    transpileSplitting: boolean;
-    transpileStub: boolean;
-    transpileTarget: import("./cfg-types").transpileTarget;
-    transpileWatch: boolean;
-    publishArtifacts?: {
-        global: string[];
-        "dist-jsr": string[];
-        "dist-npm": string[];
-        "dist-libs": Record<string, {
-            jsr: string[];
-            npm: string[];
-        }>;
-    };
-    buildPreExtensions: string[];
-    buildTemplatesDir: string;
-};