@reliverse/dler 1.7.16 → 1.7.18

package/bin/libs/sdk/sdk-impl/spell/applyMagicSpells.js

@@ -0,0 +1,474 @@
+import path, { join } from "@reliverse/pathkit";
+import fs, { readdir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import pMap from "p-map";
+import { isBinaryExt } from "../utils/binary.js";
+import { formatError } from "../utils/utils-error-cwd.js";
+import { evaluateMagicDirective } from "./spells.js";
+const DEBUG_MODE = true;
+const PROCESS_DTS_FILES = true;
+const DEFAULT_OPTIONS = {
+  concurrency: 4,
+  batchSize: 100,
+  stopOnError: false,
+  copyFileWithDirectivesFromSrcBeforeProcessing: true
+};
+const DIST_PATHS = {
+  "dist-jsr": "dist-jsr/bin",
+  "dist-npm": "dist-npm/bin",
+  "dist-libs": "dist-libs"
+};
+function validateTargets(targets) {
+  const distLibs = /* @__PURE__ */ new Set();
+  const specificLibs = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    const [dist, lib] = target.split("/");
+    if (!dist || !Object.keys(DIST_PATHS).includes(dist)) {
+      throw new Error(`Invalid distribution target: ${dist}`);
+    }
+    if (dist === "dist-libs") {
+      if (lib) {
+        if (specificLibs.has(lib)) {
+          throw new Error(`Duplicate library target: ${target}`);
+        }
+        specificLibs.add(lib);
+      } else {
+        if (distLibs.has("dist-libs") || specificLibs.size > 0) {
+          throw new Error("Cannot mix 'dist-libs' with specific library targets");
+        }
+        distLibs.add("dist-libs");
+      }
+    } else {
+      if (distLibs.has(dist)) {
+        throw new Error(`Duplicate distribution target: ${dist}`);
+      }
+      distLibs.add(dist);
+    }
+  }
+}
+export async function applyMagicSpells(targets, options = {}) {
+  const result = {
+    processedFiles: []
+  };
+  try {
+    validateTargets(targets);
+    const srcRoot = path.resolve(process.cwd(), "src");
+    const sourceFilesWithDirectives = await scanSourceForMagicDirectives(srcRoot, options);
+    if (sourceFilesWithDirectives.length === 0) {
+      if (DEBUG_MODE) relinka("log", "[spells] No source files with magic directives found");
+      return result;
+    }
+    if (DEBUG_MODE) {
+      relinka(
+        "log",
+        `[spells] Found ${sourceFilesWithDirectives.length} source files with magic directives`
+      );
+    }
+    await pMap(
+      targets,
+      async (target) => {
+        const [dist, lib] = target.split("/");
+        if (dist === "dist-libs") {
+          if (!lib) {
+            const libDirs = await readdir(DIST_PATHS["dist-libs"]);
+            await pMap(
+              libDirs,
+              async (libDir) => {
+                const targetResult = await processDistributionTarget(
+                  sourceFilesWithDirectives,
+                  "dist-libs",
+                  libDir,
+                  options
+                );
+                result.processedFiles.push(...targetResult.processedFiles);
+              },
+              {
+                concurrency: options.concurrency ?? 4,
+                stopOnError: options.stopOnError ?? true
+              }
+            );
+          } else {
+            const targetResult = await processDistributionTarget(
+              sourceFilesWithDirectives,
+              "dist-libs",
+              lib,
+              options
+            );
+            result.processedFiles.push(...targetResult.processedFiles);
+          }
+        } else {
+          const targetResult = await processDistributionTarget(
+            sourceFilesWithDirectives,
+            dist,
+            void 0,
+            options
+          );
+          result.processedFiles.push(...targetResult.processedFiles);
+        }
+      },
+      {
+        concurrency: options.concurrency ?? 3,
+        stopOnError: options.stopOnError ?? true
+      }
+    );
+    return result;
+  } catch (error) {
+    throw new Error(`Failed to process distribution files: ${formatError(error)}`);
+  }
+}
+async function scanSourceForMagicDirectives(srcRoot, options = {}) {
+  if (DEBUG_MODE) {
+    relinka("log", `[spells] \u21D2 scanning src: ${srcRoot}`);
+  }
+  const sourceFilesWithDirectives = [];
+  try {
+    for await (const filePath of walkDirectoryTree(srcRoot)) {
+      if (await isBinaryExt(filePath)) {
+        continue;
+      }
+      const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+      if (await isSpellImplementationFile(projectRel)) {
+        continue;
+      }
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        if (containsMagicDirectives(content)) {
+          sourceFilesWithDirectives.push(filePath);
+          if (DEBUG_MODE) {
+            relinka(
+              "log",
+              `[spells] \u21D2 found directives in ${path.relative(process.cwd(), filePath)}`
+            );
+          }
+        }
+      } catch (error) {
+        if (options.stopOnError) {
+          throw new Error(`Failed to read source file ${filePath}: ${formatError(error)}`);
+        }
+        relinka("error", `Failed to read source file ${filePath}: ${formatError(error)}`);
+      }
+    }
+  } catch (error) {
+    if (options.stopOnError) {
+      throw new Error(`Failed to scan source directory: ${formatError(error)}`);
+    }
+    relinka("error", `Failed to scan source directory: ${formatError(error)}`);
+  }
+  return sourceFilesWithDirectives;
+}
+async function processDistributionTarget(sourceFilesWithDirectives, dist, libName, options = {}) {
+  const { concurrency = DEFAULT_OPTIONS.concurrency, batchSize = DEFAULT_OPTIONS.batchSize } = options;
+  const result = {
+    processedFiles: []
+  };
+  if (DEBUG_MODE) {
+    const targetName = dist === "dist-libs" && libName ? `${dist}/${libName}` : dist;
+    relinka("log", `[spells] \u21D2 processing target: ${targetName}`);
+  }
+  const distFilesToProcess = [];
+  for (const sourceFile of sourceFilesWithDirectives) {
+    const distFiles = await findDistributionFiles(sourceFile, dist, libName);
+    distFilesToProcess.push(...distFiles);
+  }
+  if (distFilesToProcess.length === 0) {
+    if (DEBUG_MODE) {
+      const targetName = dist === "dist-libs" && libName ? `${dist}/${libName}` : dist;
+      relinka("log", `[spells] No corresponding dist files found for target: ${targetName}`);
+    }
+    return result;
+  }
+  for (let i = 0; i < distFilesToProcess.length; i += batchSize) {
+    const batch = distFilesToProcess.slice(i, i + batchSize);
+    await pMap(
+      batch,
+      async (distFilePath) => {
+        try {
+          const wasProcessed = await processSingleDistFile(distFilePath, options);
+          if (wasProcessed) {
+            result.processedFiles.push(distFilePath);
+          }
+        } catch (error) {
+          const errorMessage = `Error processing ${distFilePath}: ${formatError(error)}`;
+          if (options.stopOnError) {
+            throw new Error(errorMessage);
+          }
+          relinka("error", errorMessage);
+        }
+      },
+      { concurrency }
+    );
+  }
+  return result;
+}
+async function findSourceFile(distFilePath) {
+  const projectRel = path.relative(process.cwd(), distFilePath).replaceAll(path.sep, "/");
+  const ext = path.extname(distFilePath);
+  const baseName = path.basename(distFilePath, ext);
+  const dirName = path.dirname(projectRel);
+  let sourcePath;
+  if (dirName.startsWith("dist-libs/")) {
+    const match = dirName.match(/^dist-libs\/([^/]+)(?:\/(?:npm|jsr))?(?:\/bin)?\/?(.*)$/);
+    if (match) {
+      const [, libName, remainingPath] = match;
+      sourcePath = `src/libs/${libName}${remainingPath ? `/${remainingPath}` : ""}`;
+    } else {
+      sourcePath = dirName.replace(/^dist-libs\//, "src/libs/");
+    }
+  } else {
+    sourcePath = dirName.replace(/^dist-(?:jsr|npm)(?:\/bin)?\/?/, "src/");
+  }
+  const sourceDir = path.join(process.cwd(), sourcePath);
+  if (ext === ".js") {
+    const tsFile = path.join(sourceDir, `${baseName}.ts`);
+    if (await fs.pathExists(tsFile)) {
+      const isDts = tsFile.endsWith(".d.ts");
+      if (!isDts) {
+        return tsFile;
+      }
+    }
+    const jsFile = path.join(sourceDir, `${baseName}.js`);
+    if (await fs.pathExists(jsFile)) {
+      return jsFile;
+    }
+  } else if (ext === ".ts") {
+    const isDts = path.basename(distFilePath).endsWith(".d.ts");
+    if (isDts && !PROCESS_DTS_FILES) {
+      return null;
+    }
+    const sourceFile = path.join(sourceDir, `${baseName}${ext}`);
+    if (await fs.pathExists(sourceFile)) {
+      return sourceFile;
+    }
+  } else {
+    const sourceFile = path.join(sourceDir, `${baseName}${ext}`);
+    if (await fs.pathExists(sourceFile)) {
+      return sourceFile;
+    }
+  }
+  return null;
+}
+async function processSingleDistFile(filePath, options = {}) {
+  const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+  if (await isBinaryExt(filePath)) {
+    if (DEBUG_MODE) relinka("log", `[spells] \u2298 binary  ${projectRel}`);
+    return false;
+  }
+  let copiedFromSource = false;
+  if (options.copyFileWithDirectivesFromSrcBeforeProcessing ?? DEFAULT_OPTIONS.copyFileWithDirectivesFromSrcBeforeProcessing) {
+    const sourceFile = await findSourceFile(filePath);
+    if (sourceFile) {
+      try {
+        await fs.copyFile(sourceFile, filePath);
+        copiedFromSource = true;
+        if (DEBUG_MODE)
+          relinka("log", `[spells] \u21B3 copied from ${path.relative(process.cwd(), sourceFile)}`);
+      } catch (error) {
+        relinka("error", `Failed to copy from source: ${formatError(error)}`);
+      }
+    }
+  }
+  if (copiedFromSource || await fs.pathExists(filePath)) {
+    const source = await fs.readFile(filePath, "utf8");
+    const ctx = { filePath: projectRel };
+    let removeFile = false;
+    const processedLines = [];
+    for (const line of source.split(/\r?\n/)) {
+      const outcome = evaluateMagicDirective(line, ctx);
+      if (outcome.removeFile) {
+        removeFile = true;
+        break;
+      }
+      if (!outcome.removeLine) {
+        processedLines.push(outcome.replacement ?? line);
+      }
+    }
+    if (removeFile) {
+      await fs.unlink(filePath);
+      if (DEBUG_MODE) relinka("log", `[spells] \u2716 removed ${projectRel}`);
+      return false;
+    }
+    const newContent = processedLines.join("\n");
+    if (newContent !== source) {
+      await fs.writeFile(filePath, newContent, "utf8");
+      if (DEBUG_MODE) relinka("log", `[spells] \u2713 updated ${projectRel}`);
+    }
+    return true;
+  }
+  return false;
+}
+async function findDistributionFiles(sourceFilePath, dist, libName) {
+  const projectRel = path.relative(process.cwd(), sourceFilePath).replaceAll(path.sep, "/");
+  const srcRelativePath = projectRel.replace(/^src\//, "");
+  const ext = path.extname(sourceFilePath);
+  const baseName = path.basename(sourceFilePath, ext);
+  const dirPath = path.dirname(srcRelativePath);
+  const isDts = sourceFilePath.endsWith(".d.ts");
+  const distFiles = [];
+  if (dist === "dist-libs" && libName) {
+    const targets = await getAvailableRegistries(libName);
+    for (const target of targets) {
+      const distPath = join("dist-libs", libName, target, "bin", dirPath === "." ? "" : dirPath);
+      let extensions;
+      if (isDts && PROCESS_DTS_FILES) {
+        extensions = [".d.ts"];
+      } else if (ext === ".ts" && !isDts) {
+        extensions = [".js", ".ts"];
+      } else {
+        extensions = [ext];
+      }
+      for (const distExt of extensions) {
+        const distFile = path.join(process.cwd(), distPath, `${baseName}${distExt}`);
+        if (await fs.pathExists(distFile)) {
+          distFiles.push(distFile);
+        }
+      }
+    }
+  } else {
+    const basePath = DIST_PATHS[dist];
+    const distPath = path.join(basePath, dirPath === "." ? "" : dirPath);
+    let extensions;
+    if (isDts && PROCESS_DTS_FILES) {
+      extensions = [".d.ts"];
+    } else if (ext === ".ts" && !isDts) {
+      extensions = [".js", ".ts"];
+    } else {
+      extensions = [ext];
+    }
+    for (const distExt of extensions) {
+      const distFile = path.join(process.cwd(), distPath, `${baseName}${distExt}`);
+      if (await fs.pathExists(distFile)) {
+        distFiles.push(distFile);
+      }
+    }
+  }
+  return distFiles;
+}
+const SPELL_REGEX = /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i;
+let spellImplementationPaths = null;
+async function getSpellImplementationPaths() {
+  if (spellImplementationPaths !== null) {
+    return spellImplementationPaths;
+  }
+  const paths = [];
+  const distLibsPath = path.join(process.cwd(), "dist-libs");
+  try {
+    if (await fs.pathExists(distLibsPath)) {
+      const libDirs = await fs.readdir(distLibsPath, { withFileTypes: true });
+      for (const libDir of libDirs) {
+        if (libDir.isDirectory()) {
+          const libName = libDir.name;
+          paths.push(`/libs/${libName}/sdk-impl/spell/`);
+          paths.push(`/${libName}/sdk-impl/spell/`);
+          const libPath = path.join(distLibsPath, libName);
+          try {
+            const registryDirs = await fs.readdir(libPath, { withFileTypes: true });
+            for (const registryDir of registryDirs) {
+              if (registryDir.isDirectory() && (registryDir.name === "npm" || registryDir.name === "jsr")) {
+                const registryName = registryDir.name;
+                paths.push(`/libs/${libName}/${registryName}/sdk-impl/spell/`);
+                paths.push(`/${libName}/${registryName}/sdk-impl/spell/`);
+              }
+            }
+          } catch (error) {
+            if (DEBUG_MODE) {
+              relinka("warn", `Failed to read library directory ${libPath}: ${formatError(error)}`);
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to read dist-libs directory: ${formatError(error)}`);
+    }
+  }
+  if (paths.length === 0) {
+    paths.push("/libs/sdk/sdk-impl/spell/", "/sdk-impl/spell/");
+  }
+  spellImplementationPaths = paths;
+  return paths;
+}
+async function isSpellImplementationFile(projectRelPath) {
+  const spellPaths = await getSpellImplementationPaths();
+  return spellPaths.some((spellPath) => projectRelPath.includes(spellPath));
+}
+const libraryRegistriesCache = /* @__PURE__ */ new Map();
+async function getAvailableRegistries(libName) {
+  const cached = libraryRegistriesCache.get(libName);
+  if (cached) {
+    return cached;
+  }
+  const registries = [];
+  const libPath = path.join(process.cwd(), "dist-libs", libName);
+  try {
+    if (await fs.pathExists(libPath)) {
+      const entries = await fs.readdir(libPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && (entry.name === "npm" || entry.name === "jsr")) {
+          registries.push(entry.name);
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to read library registries for ${libName}: ${formatError(error)}`);
+    }
+  }
+  if (registries.length === 0) {
+    registries.push("npm", "jsr");
+  }
+  libraryRegistriesCache.set(libName, registries);
+  return registries;
+}
+let allAvailableRegistriesCache = null;
+export async function getAllAvailableRegistries() {
+  if (allAvailableRegistriesCache !== null) {
+    return allAvailableRegistriesCache;
+  }
+  const allRegistries = /* @__PURE__ */ new Set();
+  const distLibsPath = path.join(process.cwd(), "dist-libs");
+  try {
+    if (await fs.pathExists(distLibsPath)) {
+      const libDirs = await fs.readdir(distLibsPath, { withFileTypes: true });
+      for (const libDir of libDirs) {
+        if (libDir.isDirectory()) {
+          const registries = await getAvailableRegistries(libDir.name);
+          for (const registry of registries) {
+            allRegistries.add(registry);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to scan all registries: ${formatError(error)}`);
+    }
+  }
+  if (allRegistries.size === 0) {
+    allRegistries.add("npm");
+    allRegistries.add("jsr");
+  }
+  allAvailableRegistriesCache = Array.from(allRegistries);
+  return allAvailableRegistriesCache;
+}
+function containsMagicDirectives(content) {
+  const lines = content.split(/\r?\n/);
+  return lines.some((line) => SPELL_REGEX.test(line));
+}
+async function* walkDirectoryTree(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        yield* walkDirectoryTree(full);
+      } else if (entry.isFile()) {
+        yield full;
+      }
+    }
+  } catch (error) {
+    const errorMessage = `Error walking directory ${dir}: ${formatError(error)}`;
+    relinka("error", errorMessage);
+    throw new Error(errorMessage);
+  }
+}

package/bin/libs/sdk/sdk-impl/spell/spells.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Spell engine – parses and evaluates magic comments embedded
+ * in a single line of code.
+ *
+ * Supported directives:
+ *   // <dler-replace-line-to `NEW CONTENT` [if 'cond'] [else 'alt']>
+ *   // <dler-remove-line>
+ *   // <dler-remove-file>
+ *
+ * A directive is recognised whether written as:
+ *   // <dler-…>                or
+ *   // @ts-expect-error * <dler-…>
+ *
+ * Conditions (if/else) – currently supported:
+ *   current file path starts with <prefix> [or <prefix> ...]
+ */
+export interface SpellEvaluationContext {
+    /** Path relative to project root (slash-separated) */
+    filePath: string;
+}
+export interface SpellOutcome {
+    replacement?: string;
+    removeLine: boolean;
+    removeFile: boolean;
+}
+export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file";
+/**
+ * Evaluates a single line for magic directives and returns the effect.
+ * If no directive is present, returns neutral outcome.
+ */
+export declare function evaluateMagicDirective(line: string, ctx: SpellEvaluationContext): SpellOutcome;

package/bin/libs/sdk/sdk-impl/spell/spells.js

@@ -0,0 +1,85 @@
+import { relinka } from "@reliverse/relinka";
+const SPELL_REGEX = /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i;
+const REPLACEMENT_REGEX = /`([^`]+)`/;
+const IF_CONDITION_REGEX = /\bif\s+['"`]([^'"`]+)['"`]/i;
+const ELSE_CONTENT_REGEX = /\belse\s+['"`]([^'"`]+)['"`]/i;
+const STARTS_WITH_REGEX = /current file path starts with\s+(.+)$/i;
+export function evaluateMagicDirective(line, ctx) {
+  const match = line.match(SPELL_REGEX);
+  if (!match) return NO_OP;
+  const [, directive = "", body] = match;
+  if (!isValidMagicDirective(directive)) {
+    relinka("warn", `[spells] unknown directive: ${directive}`);
+    return NO_OP;
+  }
+  switch (directive) {
+    /* -------------------------------------------------------------- */
+    /* dler-remove-file                                               */
+    /* -------------------------------------------------------------- */
+    case "dler-remove-file": {
+      return { removeFile: true, removeLine: true };
+    }
+    /* -------------------------------------------------------------- */
+    /* dler-remove-line                                               */
+    /* -------------------------------------------------------------- */
+    case "dler-remove-line": {
+      return { removeLine: true, removeFile: false };
+    }
+    /* -------------------------------------------------------------- */
+    /* dler-replace-line-to                                           */
+    /* -------------------------------------------------------------- */
+    case "dler-replace-line-to": {
+      const { replacement, elseContent, condition } = parseReplacementDirective(body ?? "");
+      if (!replacement) {
+        relinka("warn", "[spells] dler-replace-line-to missing replacement content");
+        return NO_OP;
+      }
+      const condMet = condition === void 0 ? true : evaluatePathCondition(condition, ctx);
+      if (condMet) {
+        return { replacement, removeLine: false, removeFile: false };
+      }
+      if (elseContent !== void 0) {
+        return { replacement: elseContent, removeLine: false, removeFile: false };
+      }
+      return NO_OP;
+    }
+    default:
+      return NO_OP;
+  }
+}
+const NO_OP = { removeLine: false, removeFile: false };
+function isValidMagicDirective(directive) {
+  return ["dler-replace-line-to", "dler-remove-line", "dler-remove-file"].includes(directive);
+}
+function parseReplacementDirective(body) {
+  const parts = {
+    replacement: ""
+  };
+  const replacementMatch = body.match(REPLACEMENT_REGEX);
+  if (replacementMatch?.[1]) parts.replacement = replacementMatch[1].trim();
+  const ifMatch = body.match(IF_CONDITION_REGEX);
+  if (ifMatch?.[1]) {
+    parts.condition = ifMatch[1].trim();
+  } else {
+    parts.condition = "current file path starts with dist-jsr or dist-npm";
+  }
+  const elseMatch = body.match(ELSE_CONTENT_REGEX);
+  if (elseMatch?.[1]) parts.elseContent = elseMatch[1].trim();
+  return parts;
+}
+function evaluatePathCondition(condition, ctx) {
+  const STARTS_WITH = STARTS_WITH_REGEX.exec(condition)?.[1];
+  if (STARTS_WITH) {
+    const prefixes = STARTS_WITH.split(/\s+or\s+/i).map(
+      (p) => p.replace(/['"`]/g, "").trim().replaceAll("\\", "/")
+    );
+    return prefixes.some((p) => ctx.filePath.startsWith(p));
+  }
+  if (condition.trim()) {
+    relinka(
+      "warn",
+      `[spells] unsupported condition "${condition}" - only "current file path starts with <prefix> [or <prefix> ...]" is supported`
+    );
+  }
+  return false;
+}

package/bin/libs/sdk/sdk-impl/utils/binary.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "@reliverse/pathkit";
 import { BINARY_SET } from "./b-exts.js";
 import { isBinary } from "./file-type.js";
 export const isBinaryExt = async (file) => {

package/bin/libs/sdk/sdk-impl/utils/comments.d.ts

@@ -0,0 +1,6 @@
+export type CommentStyle = "// " | "# " | "-- " | "/* " | "<!-- ";
+export type FileExtension = "js" | "jsx" | "ts" | "tsx" | "c" | "cpp" | "h" | "java" | "go" | "kt" | "swift" | "rs" | "cs" | "json" | "proto" | "dart" | "inc" | "pwn" | "py" | "rb" | "sh" | "pl" | "r" | "yml" | "yaml" | "sql" | "lua" | "css" | "scss" | "less" | "html" | "htm" | "xml" | "md";
+export type CommentMapping = Record<FileExtension, CommentStyle>;
+export declare const DEFAULT_COMMENT: "// ";
+export declare const COMMENT_MAP: CommentMapping;
+export declare const getCommentPrefix: (filePath: string, forceComment?: boolean, customComment?: string) => string;

package/bin/libs/sdk/sdk-impl/utils/comments.js

@@ -0,0 +1,41 @@
+export const DEFAULT_COMMENT = "// ";
+const createCommentMapping = (extensions, comment) => Object.fromEntries(extensions.map((ext) => [ext, comment]));
+export const COMMENT_MAP = {
+  // Single-line comment style //
+  ...createCommentMapping(
+    [
+      "js",
+      "jsx",
+      "ts",
+      "tsx",
+      "c",
+      "cpp",
+      "h",
+      "java",
+      "go",
+      "kt",
+      "swift",
+      "rs",
+      "cs",
+      "json",
+      "proto",
+      "dart",
+      "inc",
+      "pwn"
+    ],
+    "// "
+  ),
+  // Single-line comment style #
+  ...createCommentMapping(["py", "rb", "sh", "pl", "r", "yml", "yaml"], "# "),
+  // Single-line comment style --
+  ...createCommentMapping(["sql", "lua"], "-- "),
+  // Multi-line comment style /* */
+  ...createCommentMapping(["css", "scss", "less"], "/* "),
+  // Multi-line comment style <!-- -->
+  ...createCommentMapping(["html", "htm", "xml", "md"], "<!-- ")
+};
+export const getCommentPrefix = (filePath, forceComment, customComment) => {
+  if (forceComment && customComment) return customComment;
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
+};

package/bin/libs/sdk/sdk-impl/utils/finalize.d.ts

@@ -1,4 +1,5 @@
-import type { LibConfig, PerfTimer } from "../../sdk-types.js";
+import type { LibConfig } from "../config/types.js";
+import type { PerfTimer } from "../../sdk-types.js";
 /**
  * Finalizes the build process and reports completion.
  */

package/bin/libs/sdk/sdk-impl/utils/finalize.js

@@ -19,6 +19,7 @@ export async function finalizeBuildPub(timer, commonPubPause, libsList, distNpmD
   if (!commonPubPause) {
     relinka("success", `\u{1F389} Publish completed successfully (build time: ${transpileFormattedTime})`);
   } else {
+    console.log("-".repeat(50));
     relinka("success", `\u{1F389} Build completed successfully (done in: ${transpileFormattedTime})`);
     relinka("info", "\u{1F4DD} Publish process is currently paused in your config file");
   }

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const WHITELABEL_DEFAULT = "DLER";
+export declare const JSON_EXTS: Set<string>;
+export declare const TEMPLATE_VAR: (tpl: string, wl: string) => string;
+export declare const TPLS_DIR = "tpls";
+export declare const BINARIES_DIR = "binaries";
+export declare const isJsonExt: (f: string) => boolean;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js

@@ -0,0 +1,7 @@
+import path from "@reliverse/pathkit";
+export const WHITELABEL_DEFAULT = "DLER";
+export const JSON_EXTS = /* @__PURE__ */ new Set(["json", "jsonc", "json5", "jsonl"]);
+export const TEMPLATE_VAR = (tpl, wl) => `${tpl.toUpperCase()}_${wl.toUpperCase()}_TEMPLATE`;
+export const TPLS_DIR = "tpls";
+export const BINARIES_DIR = "binaries";
+export const isJsonExt = (f) => JSON_EXTS.has(path.extname(f).slice(1).toLowerCase());

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.d.ts

@@ -0,0 +1,5 @@
+import type { FileType, TemplatesFileContent } from "./pu-types";
+export declare const walkDir: (dir: string) => Promise<string[]>;
+export declare const detectFileType: (file: string) => Promise<FileType>;
+export declare const readFileForTemplate: (absPath: string) => Promise<TemplatesFileContent>;
+export declare const escapeTemplateString: (src: string) => string;