@reliverse/dler 1.7.75 → 1.7.76

package/bin/app/agg/cmd.js

@@ -1,6 +1,6 @@
 import path from "@reliverse/pathkit";
 import { inputPrompt, defineArgs, defineCommand } from "@reliverse/rempts";
-import { useAggregator } from "../../libs/sdk/sdk-impl/utils/agg/agg.js";
+import { useAggregator } from "../../libs/sdk/sdk-impl/utils/agg/agg-2.js";
 export default defineCommand({
   args: defineArgs({
     imports: {

package/bin/cli.js

@@ -3,7 +3,7 @@ import { runMain, defineCommand, defineArgs, selectPrompt, showUsage } from "@re
 import { callCmd } from "./app/cmds.js";
 import { showEndPrompt, showStartPrompt } from "./libs/sdk/sdk-impl/config/info.js";
 import { prepareDlerEnvironment } from "./libs/sdk/sdk-impl/config/prepare.js";
-import { promptAggCommand } from "./libs/sdk/sdk-impl/utils/agg/agg.js";
+import { promptAggCommand } from "./libs/sdk/sdk-impl/utils/agg/agg-1.js";
 const MENU_CMDS = ["agg", "build", "pub", "update"];
 let isDev = process.env.DLER_DEV_MODE === "true";
 const main = defineCommand({

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.75";
+const version = "1.7.76";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/utils/agg/agg-1.d.ts

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

package/bin/libs/sdk/sdk-impl/utils/agg/agg-1.js

@@ -0,0 +1,194 @@
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt, confirmPrompt, inputPrompt } from "@reliverse/rempts";
+import { getConfigDler } from "../../config/load.js";
+import { useAggregator } from "./agg-2.js";
+import { findMainEntryFile } from "./agg-4.js";
+import { isAggregationDisabled } from "./agg-5.js";
+export async function promptAggCommand() {
+  const config = await getConfigDler();
+  let selectedLibName = null;
+  const mainEntryFile = await findMainEntryFile(config);
+  const isMainDisabled = mainEntryFile ? await isAggregationDisabled(mainEntryFile) : false;
+  if (config?.libsList && Object.keys(config.libsList).length > 0) {
+    const libEntries = await Promise.all(
+      Object.entries(config.libsList).map(async ([name, lib]) => {
+        const libMainFile = `${config.libsDirSrc}/${lib.libMainFile}`;
+        const isLibDisabled = await isAggregationDisabled(libMainFile);
+        return {
+          name,
+          lib,
+          isDisabled: isLibDisabled
+        };
+      })
+    );
+    const libs = libEntries.filter(({ isDisabled }) => !isDisabled).map(({ name, lib }) => ({
+      value: name,
+      label: name,
+      hint: `${config.libsDirSrc}/${lib.libDirName}/${lib.libDirName}-impl`
+    }));
+    if (mainEntryFile && !isMainDisabled) {
+      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 && !isMainDisabled) {
+    const shouldUseMain = await confirmPrompt({
+      title: `Use main package for aggregation? (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 && !isMainDisabled) {
+      const entryDir = path.dirname(mainEntryFile);
+      input = entryDir;
+      out = mainEntryFile;
+      strip = entryDir;
+    } else if (selectedLibName === "main" && isMainDisabled) {
+      relinka.log("Main package aggregation is disabled due to <dler-disable-agg> comment.");
+      return;
+    } 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
+    });
+    if (input) {
+      if (mainEntryFile && isMainDisabled) {
+        const mainEntryDir = path.dirname(mainEntryFile);
+        if (path.resolve(input) === path.resolve(mainEntryDir) || path.resolve(input) === path.resolve(mainEntryFile)) {
+          relinka.log("Main package aggregation is disabled due to <dler-disable-agg> comment.");
+          return;
+        }
+      }
+      if (config?.libsList) {
+        for (const [libName, libConfig] of Object.entries(config.libsList)) {
+          const libImplPath = `${config.libsDirSrc}/${libConfig.libDirName}/${libConfig.libDirName}-impl`;
+          const libMainFile = `${config.libsDirSrc}/${libConfig.libMainFile}`;
+          if (path.resolve(input) === path.resolve(libImplPath) || path.resolve(input) === path.resolve(libMainFile)) {
+            const isLibDisabled = await isAggregationDisabled(libMainFile);
+            if (isLibDisabled) {
+              relinka.log(
+                `Library "${libName}" aggregation is disabled due to <dler-disable-agg> comment.`
+              );
+              return;
+            }
+          }
+        }
+      }
+    }
+  }
+  const verbose = await confirmPrompt({
+    title: "Enable verbose logging and additional options?",
+    defaultValue: false
+  });
+  let sortLines = false;
+  let headerComment = "";
+  let includeInternal = false;
+  let internalMarker = "#";
+  let overrideFile = false;
+  let extensions = ".ts,.js,.mts,.cts,.mjs,.cjs";
+  if (verbose) {
+    sortLines = await confirmPrompt({
+      title: "Sort aggregated lines alphabetically?",
+      defaultValue: false
+    });
+    headerComment = await inputPrompt({
+      title: "Add a header comment to the aggregator output (optional):",
+      defaultValue: ""
+    });
+    includeInternal = await confirmPrompt({
+      title: "Include files marked as internal (starting with #)?",
+      defaultValue: false
+    });
+    internalMarker = await inputPrompt({
+      title: "Marker for internal files:",
+      defaultValue: "#"
+    });
+    overrideFile = await confirmPrompt({
+      title: "Override entire file instead of updating only the aggregator block?",
+      defaultValue: false
+    });
+    extensions = await inputPrompt({
+      title: "File extensions to process (comma-separated):",
+      defaultValue: ".ts,.js,.mts,.cts,.mjs,.cjs"
+    });
+    imports = await confirmPrompt({
+      title: "Do you want to generate imports instead of exports? (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
+    });
+    recursive = await confirmPrompt({
+      title: "Do you want to recursively scan subdirectories?",
+      defaultValue: recursive
+    });
+    separateTypesFile = await confirmPrompt({
+      title: "Do you want to create a separate file for type exports?",
+      defaultValue: separateTypesFile
+    });
+  }
+  if (!selectedLibName || !out) {
+    out = await inputPrompt({
+      title: "Enter the output file",
+      defaultValue: out
+    });
+  }
+  if (!selectedLibName || !strip) {
+    strip = await inputPrompt({
+      title: "Enter the path to strip from the final imports/exports",
+      defaultValue: strip
+    });
+  }
+  if (separateTypesFile) {
+    typesOut = await inputPrompt({
+      title: "Enter the output file for types",
+      defaultValue: out.replace(/\.(ts|js)$/, ".types.$1")
+    });
+  }
+  await useAggregator({
+    inputDir: path.resolve(input),
+    isRecursive: recursive,
+    outFile: path.resolve(out),
+    stripPrefix: strip ? path.resolve(strip) : "",
+    useImport: imports,
+    useNamed: named,
+    sortLines,
+    headerComment,
+    verbose,
+    includeInternal,
+    internalMarker,
+    overrideFile,
+    fileExtensions: extensions.split(",").map((ext) => ext.trim()),
+    separateTypesFile,
+    typesOutFile: typesOut ? path.resolve(typesOut) : void 0
+  });
+}

package/bin/libs/sdk/sdk-impl/utils/agg/{agg.d.ts → agg-2.d.ts}

@@ -1,4 +1,3 @@
-export declare function promptAggCommand(): Promise<void>;
 /**
  * Aggregator supporting:
  * - --import or default export,
@@ -34,7 +33,3 @@ export declare function useAggregator({ inputDir, isRecursive, outFile, stripPre
     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/libs/sdk/sdk-impl/utils/agg/agg-2.js

@@ -0,0 +1,148 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { collectFiles, generateAggregatorLines } from "./agg-3.js";
+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);
+  }
+}

package/bin/libs/sdk/sdk-impl/utils/agg/agg-3.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Build a relative import/export path, removing `stripPrefix` if it is truly a prefix,
+ * converting .ts -> .js, and ensuring it starts with "./" or "../".
+ */
+export declare function buildPathRelative(filePath: string, inputDir: string, stripPrefix: string): string;
+/**
+ * Recursively collects files with given extensions, ignoring specified directories
+ * and files marked as internal.
+ */
+export declare function collectFiles(dir: string, exts: string[], recursive: boolean, ignoreDirs: string[], verbose: boolean, includeInternal: boolean, internalMarker: string, outFile?: string): Promise<string[]>;
+/**
+ * Creates aggregator lines for a single file.
+ *
+ * If `useNamed` is true, parses named exports and produces up to two lines:
+ *   - import type { ... } / export type { ... }
+ *   - import { ... } / export { ... }
+ *
+ * If `useNamed` is false, produces a single star import or export.
+ *
+ * @param usedIdentifiers A set to track and ensure unique identifiers for star imports.
+ */
+export declare function generateAggregatorLines(filePath: string, inputDir: string, stripPrefix: string, useImport: boolean, useNamed: boolean, usedIdentifiers?: Set<string>): Promise<string[]>;
+/**
+ * Parses a file to extract named exports, separating type exports from value exports.
+ * Deduplicates export names (to handle overloads).
+ */
+export declare function getNamedExports(filePath: string): Promise<{
+    typeNames: string[];
+    valueNames: string[];
+}>;
+/**
+ * Generates a valid identifier for star imports based on the file name.
+ * For star imports, we generate an identifier from the filename, e.g.
+ *  'utils-cwd.ts' -> 'utils_cwd'
+ * so we do: import * as utils_cwd from "./utils-cwd";
+ */
+export declare function guessStarImportIdentifier(filePath: string): string;
+/**
+ * Prints usage examples based on whether dev mode or not.
+ */
+export declare function printUsage(isDev?: boolean): void;

package/bin/libs/sdk/sdk-impl/utils/agg/agg-3.js

@@ -0,0 +1,197 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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: [] };
+  }
+}
+export 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/libs/sdk/sdk-impl/utils/agg/agg-4.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if a file exists at the given path
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Finds the main package based on dler configuration with fallbacks
+ */
+export declare function findMainEntryFile(config: any): Promise<string | null>;

package/bin/libs/sdk/sdk-impl/utils/agg/agg-4.js

@@ -0,0 +1,26 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+export async function fileExists(filePath) {
+  return await fs.pathExists(filePath);
+}
+export 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;
+}

package/bin/libs/sdk/sdk-impl/utils/agg/agg-5.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if the first line of a file contains the disable aggregation comment
+ */
+export declare function isAggregationDisabled(filePath: any): Promise<boolean>;

package/bin/libs/sdk/sdk-impl/utils/agg/agg-5.js

@@ -0,0 +1,17 @@
+import fs from "@reliverse/relifso";
+
+/**
+ * Checks if the first line of a file contains the disable aggregation comment
+ */
+// @ts-expect-error TODO: SOMETHING STRANGE WITH THIS FUNCTION
+// FOR SOME REASON MKDIST DON'T WANT TO REMOVE TS ANNOTATIONS
+// FROM THIS AND ALL FUNCTIONS WHICH LIVE IN THE SAME FILE
+export async function isAggregationDisabled(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const firstLine = content.split("\n")[0]?.trim();
+    return firstLine === "// <dler-disable-agg>";
+  } catch {
+    return false;
+  }
+}