@reliverse/dler 1.3.6 → 1.4.1

package/README.md

@@ -18,6 +18,7 @@
 - 🔌 plugin system with two built-in plugins included
 - 📝 highly configurable flow via a configuration file
 - 🔜 `libraries` plugin —> dler monorepo implementation
+- 🧼 cleans up your internal logs from the build dist
 - 🪄 magic spells (built-in plugin)
 
 ### supported bundlers

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

@@ -31,5 +31,39 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         type: "string";
     };
+    sort: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    header: {
+        description: string;
+        type: "string";
+    };
+    verbose: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    includeInternal: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    internalMarker: {
+        description: string;
+        type: "string";
+        default: string;
+    };
+    override: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    extensions: {
+        description: string;
+        type: "string";
+        default: string;
+    };
 }>;
 export default _default;

package/bin/app/agg/cmd.js

@@ -1,5 +1,5 @@
+import path from "@reliverse/pathkit";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import path from "pathe";
 import { useAggregator } from "./impl.js";
 export default defineCommand({
   args: defineArgs({
@@ -27,13 +27,47 @@ export default defineCommand({
       required: true
     },
     recursive: {
-      description: "Recursively scan subdirectories (default false)",
+      description: "Recursively scan subdirectories (default true) (false means only scan the files in the current directory and not subdirectories)",
       type: "boolean",
       default: true
     },
     strip: {
       description: "Remove specified path prefix from final imports/exports",
       type: "string"
+    },
+    sort: {
+      description: "Sort aggregated lines alphabetically",
+      type: "boolean",
+      default: false
+    },
+    header: {
+      description: "Add a header comment to the aggregator output",
+      type: "string"
+    },
+    verbose: {
+      description: "Enable verbose logging",
+      type: "boolean",
+      default: false
+    },
+    includeInternal: {
+      description: "Include files marked as internal (starting with #)",
+      type: "boolean",
+      default: false
+    },
+    internalMarker: {
+      description: "Marker for internal files (default: #)",
+      type: "string",
+      default: "#"
+    },
+    override: {
+      description: "Override entire file instead of updating only the aggregator block",
+      type: "boolean",
+      default: false
+    },
+    extensions: {
+      description: "Comma-separated list of file extensions to process (default: .ts,.js,.mts,.cts,.mjs,.cjs)",
+      type: "string",
+      default: ".ts,.js,.mts,.cts,.mjs,.cjs"
     }
   }),
   async run({ args }) {
@@ -43,7 +77,14 @@ export default defineCommand({
       outFile: path.resolve(args.out),
       stripPrefix: args.strip ? path.resolve(args.strip) : "",
       useImport: !!args.imports,
-      useNamed: !!args.named
+      useNamed: !!args.named,
+      sortLines: !!args.sort,
+      headerComment: args.header || "",
+      verbose: !!args.verbose,
+      includeInternal: !!args.includeInternal,
+      internalMarker: args.internalMarker,
+      overrideFile: !!args.override,
+      fileExtensions: args.extensions.split(",").map((ext) => ext.trim())
     });
   }
 });

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

@@ -15,7 +15,7 @@
  * - 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, }: {
+export declare function useAggregator({ inputDir, isRecursive, outFile, stripPrefix, useImport, useNamed, ignoreDirs, sortLines, headerComment, verbose, includeInternal, internalMarker, overrideFile, fileExtensions, }: {
     inputDir: string;
     isRecursive: boolean;
     outFile: string;
@@ -29,6 +29,7 @@ export declare function useAggregator({ inputDir, isRecursive, outFile, stripPre
     includeInternal?: boolean;
     internalMarker?: string;
     overrideFile?: boolean;
+    fileExtensions?: string[];
 }): Promise<void>;
 /**
  * Prints usage examples based on whether dev mode or not.

package/bin/app/agg/impl.js

@@ -1,7 +1,7 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 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({
@@ -17,7 +17,8 @@ export async function useAggregator({
   verbose = false,
   includeInternal = false,
   internalMarker = "#",
-  overrideFile = false
+  overrideFile = false,
+  fileExtensions = [".ts", ".js", ".mts", ".cts", ".mjs", ".cjs"]
 }) {
   try {
     const st = await fs.stat(inputDir).catch(() => null);
@@ -25,25 +26,60 @@ export async function useAggregator({
       relinka("error", `Error: --input is not a valid directory: ${inputDir}`);
       process.exit(1);
     }
-    const exts = [".ts", ".js"];
+    const outDir = path.dirname(outFile);
+    try {
+      await fs.ensureDir(outDir);
+    } catch (error) {
+      relinka(
+        "error",
+        `Error: Cannot create output directory: ${outDir}
+${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: ${exts.join(
+        `Scanning directory ${inputDir} for files with extensions: ${fileExtensions.join(
           ", "
         )}`
       );
     const filePaths = await collectFiles(
       inputDir,
-      exts,
+      fileExtensions,
       isRecursive,
       ignoreDirs,
       verbose,
       includeInternal,
-      internalMarker
+      internalMarker,
+      outFile
     );
     if (!filePaths.length) {
-      relinka("warn", `No matching .ts/.js files found in ${inputDir}`);
+      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(
@@ -55,7 +91,10 @@ export async function useAggregator({
           useImport,
           useNamed,
           usedIdentifiers
-        )
+        ).catch((error) => {
+          relinka("error", `Error processing file ${fp}: ${error}`);
+          return [];
+        })
       )
     );
     const allLines = aggregatorLinesArrays.flat();
@@ -63,16 +102,6 @@ export async function useAggregator({
       allLines.sort();
       if (verbose) relinka("log", "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}
@@ -113,7 +142,6 @@ ${AGGREGATOR_END}
               "No aggregator block found. Appending auto-generated section."
             );
           finalText = `${existingContent.trim()}
-
 ${aggregatorBlock}`;
         } else {
           finalText = aggregatorBlock;
@@ -151,11 +179,17 @@ function buildPathRelative(filePath, inputDir, stripPrefix) {
   }
   return resolved;
 }
-async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker) {
+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) {
@@ -171,7 +205,8 @@ async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeIn
           ignoreDirs,
           verbose,
           includeInternal,
-          internalMarker
+          internalMarker,
+          outFile
         );
         found.push(...sub);
       }
@@ -239,20 +274,46 @@ async function generateAggregatorLines(filePath, inputDir, stripPrefix, useImpor
 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);
+    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 {
-          valueNamesSet.add(name);
+          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);
+            }
+          }
         }
       }
     }

package/bin/app/cmds.d.ts

@@ -85,6 +85,40 @@ export declare function cmdAgg(): Promise<import("@reliverse/rempts").Command<{
         description: string;
         type: "string";
     };
+    sort: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    header: {
+        description: string;
+        type: "string";
+    };
+    verbose: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    includeInternal: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    internalMarker: {
+        description: string;
+        type: "string";
+        default: string;
+    };
+    override: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
+    extensions: {
+        description: string;
+        type: "string";
+        default: string;
+    };
 }>>;
 export declare function cmdBuild(): Promise<import("@reliverse/rempts").Command<{
     dev: {

package/bin/app/deps/cmd.js

@@ -1,6 +1,6 @@
+import path from "@reliverse/pathkit";
 import { re } from "@reliverse/relico";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import path from "pathe";
 import { analyzeDependencies } from "./impl/analyzer.js";
 import { formatOutput } from "./impl/formatter.js";
 export default defineCommand({

package/bin/app/deps/impl/analyzer.d.ts

@@ -1,2 +1,2 @@
-import type { DependencyResult, FinderOptions } from "./types.js";
+import type { DependencyResult, FinderOptions } from "./deps-types.js";
 export declare const analyzeDependencies: (options: FinderOptions) => Promise<DependencyResult>;

package/bin/app/deps/impl/filesystem.d.ts

@@ -1,4 +1,4 @@
-import type { PackageJson } from "./types.js";
+import type { PackageJson } from "./deps-types.js";
 export declare const findSourceFiles: (directory: string, ignorePatterns: string[]) => Promise<string[]>;
 export declare const readFile: (filePath: string) => Promise<string>;
 export declare const readPackageJson: (directory: string) => Promise<PackageJson>;

package/bin/app/deps/impl/filesystem.js

@@ -1,4 +1,4 @@
-import fs from "fs-extra";
+import fs from "@reliverse/relifso";
 import { glob } from "glob";
 import path from "node:path";
 export const findSourceFiles = async (directory, ignorePatterns) => {

package/bin/app/deps/impl/formatter.d.ts

@@ -1,2 +1,2 @@
-import type { DependencyResult, FinderOptions } from "./types.js";
+import type { DependencyResult, FinderOptions } from "./deps-types.js";
 export declare const formatOutput: (result: DependencyResult, options: FinderOptions) => string;

package/bin/app/deps/impl/formatter.js

@@ -28,7 +28,6 @@ export const formatOutput = (result, options) => {
     output += chalk.gray("To install, run:\n");
     output += chalk.cyan(
       `npm install ${result.missingDependencies.join(" ")}
-
 `
     );
   } else {

package/bin/app/deps/impl/parser.d.ts

@@ -1,4 +1,4 @@
-import type { PackageJson } from "./types.js";
+import type { PackageJson } from "./deps-types.js";
 export declare const extractPackageNames: (fileContent: string) => Set<string>;
 export declare const normalizePackageName: (importPath: string) => string | null;
 export declare const getListedDependencies: (packageJson: PackageJson) => Set<string>;

package/bin/app/inject/expect/impl.js

@@ -1,7 +1,7 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { execa } from "execa";
-import fs from "fs-extra";
-import path from "pathe";
 function parseCommand(command) {
   const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
   const args = [];

package/bin/app/merge/cmd.d.ts

@@ -0,0 +1,44 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    in: {
+        type: "array";
+        description: string;
+    };
+    ignore: {
+        type: "array";
+        description: string;
+    };
+    out: {
+        type: "string";
+        description: string;
+    };
+    format: {
+        type: "string";
+        default: string;
+        description: string;
+    };
+    stdout: {
+        type: "boolean";
+        description: string;
+    };
+    noPath: {
+        type: "boolean";
+        description: string;
+    };
+    separator: {
+        type: "string";
+        description: string;
+    };
+    comment: {
+        type: "string";
+        description: string;
+    };
+    forceComment: {
+        type: "boolean";
+        description: string;
+    };
+    batch: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;