@reliverse/dler 1.7.21 → 1.7.23

package/bin/libs/sdk/sdk-impl/{spell/applyMagicSpells.js → magic/apply.js}

@@ -13,36 +13,51 @@ const DEFAULT_OPTIONS = {
   stopOnError: false,
   copyFileWithDirectivesFromSrcBeforeProcessing: true
 };
-const DIST_PATHS = {
+const DEFAULT_OUTPUT_PATHS = {
   "dist-jsr": "dist-jsr/bin",
   "dist-npm": "dist-npm/bin",
   "dist-libs": "dist-libs"
 };
-function validateTargets(targets) {
-  const distLibs = /* @__PURE__ */ new Set();
+function validateTargets(targets, customOutputPaths) {
+  const outputDirs = /* @__PURE__ */ new Set();
   const specificLibs = /* @__PURE__ */ new Set();
+  const customTargets = /* @__PURE__ */ new Set();
+  const allOutputPaths = { ...DEFAULT_OUTPUT_PATHS, ...customOutputPaths };
   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}`);
+    const [outputDir, lib] = target.split("/");
+    if (!outputDir) {
+      throw new Error(`Invalid output target: ${target}`);
     }
-    if (dist === "dist-libs") {
+    const outputPath = allOutputPaths[outputDir] || outputDir;
+    const fullPath = path.join(process.cwd(), outputPath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Output directory does not exist: ${outputPath}`);
+    }
+    const isCustomTarget = !["dist-npm", "dist-jsr", "dist-libs"].includes(outputDir);
+    if (isCustomTarget) {
+      if (customTargets.has(outputDir)) {
+        throw new Error(`Duplicate custom target: ${outputDir}`);
+      }
+      customTargets.add(outputDir);
+      continue;
+    }
+    if (outputDir === "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) {
+        if (outputDirs.has("dist-libs") || specificLibs.size > 0) {
           throw new Error("Cannot mix 'dist-libs' with specific library targets");
         }
-        distLibs.add("dist-libs");
+        outputDirs.add("dist-libs");
       }
     } else {
-      if (distLibs.has(dist)) {
-        throw new Error(`Duplicate distribution target: ${dist}`);
+      if (outputDirs.has(outputDir)) {
+        throw new Error(`Duplicate output target: ${outputDir}`);
       }
-      distLibs.add(dist);
+      outputDirs.add(outputDir);
     }
   }
 }
@@ -51,36 +66,44 @@ export async function applyMagicSpells(targets, options = {}) {
     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`
-      );
-    }
+    validateTargets(targets, options.customOutputPaths);
     await pMap(
       targets,
       async (target) => {
-        const [dist, lib] = target.split("/");
-        if (dist === "dist-libs") {
+        const [outputDir, lib] = target.split("/");
+        if (outputDir && !["dist-npm", "dist-jsr", "dist-libs"].includes(outputDir)) {
+          const targetResult = await processCustomTarget(outputDir, options);
+          result.processedFiles.push(...targetResult.processedFiles);
+          return;
+        }
+        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;
+        }
+        if (DEBUG_MODE) {
+          relinka(
+            "log",
+            `[spells] Found ${sourceFilesWithDirectives.length} source files with magic directives`
+          );
+        }
+        if (outputDir === "dist-libs") {
           if (!lib) {
-            const libDirs = await readdir(DIST_PATHS["dist-libs"]);
+            const distLibsPath = DEFAULT_OUTPUT_PATHS["dist-libs"] ?? "dist-libs";
+            const libDirs = await readdir(distLibsPath, { withFileTypes: true });
             await pMap(
               libDirs,
               async (libDir) => {
-                const targetResult = await processDistributionTarget(
-                  sourceFilesWithDirectives,
-                  "dist-libs",
-                  libDir,
-                  options
-                );
-                result.processedFiles.push(...targetResult.processedFiles);
+                if (libDir.isDirectory()) {
+                  const targetResult = await processOutputTarget(
+                    sourceFilesWithDirectives,
+                    "dist-libs",
+                    libDir.name,
+                    options
+                  );
+                  result.processedFiles.push(...targetResult.processedFiles);
+                }
               },
               {
                 concurrency: options.concurrency ?? 4,
@@ -88,7 +111,7 @@ export async function applyMagicSpells(targets, options = {}) {
               }
             );
           } else {
-            const targetResult = await processDistributionTarget(
+            const targetResult = await processOutputTarget(
               sourceFilesWithDirectives,
               "dist-libs",
               lib,
@@ -96,10 +119,10 @@ export async function applyMagicSpells(targets, options = {}) {
             );
             result.processedFiles.push(...targetResult.processedFiles);
           }
-        } else {
-          const targetResult = await processDistributionTarget(
+        } else if (outputDir) {
+          const targetResult = await processOutputTarget(
             sourceFilesWithDirectives,
-            dist,
+            outputDir,
             void 0,
             options
           );
@@ -113,9 +136,74 @@ export async function applyMagicSpells(targets, options = {}) {
     );
     return result;
   } catch (error) {
-    throw new Error(`Failed to process distribution files: ${formatError(error)}`);
+    throw new Error(`Failed to process output files: ${formatError(error)}`);
   }
 }
+async function processCustomTarget(outputDir, options = {}) {
+  const { concurrency = DEFAULT_OPTIONS.concurrency, batchSize = DEFAULT_OPTIONS.batchSize } = options;
+  const result = {
+    processedFiles: []
+  };
+  if (DEBUG_MODE) {
+    relinka("log", `[spells] \u21D2 processing custom target: ${outputDir}`);
+  }
+  const outputFilesToProcess = [];
+  const outputPath = options.customOutputPaths?.[outputDir] || outputDir;
+  const fullOutputPath = path.join(process.cwd(), outputPath);
+  for await (const filePath of walkDirectoryTree(fullOutputPath)) {
+    if (await isBinaryExt(filePath)) {
+      continue;
+    }
+    try {
+      const content = await fs.readFile(filePath, "utf8");
+      if (containsMagicDirectives(content)) {
+        outputFilesToProcess.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 file ${filePath}: ${formatError(error)}`);
+      }
+      relinka("error", `Failed to read file ${filePath}: ${formatError(error)}`);
+    }
+  }
+  if (outputFilesToProcess.length === 0) {
+    if (DEBUG_MODE) {
+      relinka(
+        "log",
+        `[spells] No files with magic directives found in custom target: ${outputDir}`
+      );
+    }
+    return result;
+  }
+  for (let i = 0; i < outputFilesToProcess.length; i += batchSize) {
+    const batch = outputFilesToProcess.slice(i, i + batchSize);
+    await pMap(
+      batch,
+      async (outputFilePath) => {
+        try {
+          const wasProcessed = await processSingleOutputFile(outputFilePath, options);
+          if (wasProcessed) {
+            result.processedFiles.push(outputFilePath);
+          }
+        } catch (error) {
+          const errorMessage = `Error processing ${outputFilePath}: ${formatError(error)}`;
+          if (options.stopOnError) {
+            throw new Error(errorMessage);
+          }
+          relinka("error", errorMessage);
+        }
+      },
+      { concurrency }
+    );
+  }
+  return result;
+}
 async function scanSourceForMagicDirectives(srcRoot, options = {}) {
   if (DEBUG_MODE) {
     relinka("log", `[spells] \u21D2 scanning src: ${srcRoot}`);
@@ -156,39 +244,44 @@ async function scanSourceForMagicDirectives(srcRoot, options = {}) {
   }
   return sourceFilesWithDirectives;
 }
-async function processDistributionTarget(sourceFilesWithDirectives, dist, libName, options = {}) {
+async function processOutputTarget(sourceFilesWithDirectives, outputDir, 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;
+    const targetName = outputDir === "dist-libs" && libName ? `${outputDir}/${libName}` : outputDir;
     relinka("log", `[spells] \u21D2 processing target: ${targetName}`);
   }
-  const distFilesToProcess = [];
+  const outputFilesToProcess = [];
   for (const sourceFile of sourceFilesWithDirectives) {
-    const distFiles = await findDistributionFiles(sourceFile, dist, libName);
-    distFilesToProcess.push(...distFiles);
+    const outputFiles = await findOutputFiles(
+      sourceFile,
+      outputDir,
+      libName,
+      options.customOutputPaths
+    );
+    outputFilesToProcess.push(...outputFiles);
   }
-  if (distFilesToProcess.length === 0) {
+  if (outputFilesToProcess.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}`);
+      const targetName = outputDir === "dist-libs" && libName ? `${outputDir}/${libName}` : outputDir;
+      relinka("log", `[spells] No corresponding output files found for target: ${targetName}`);
     }
     return result;
   }
-  for (let i = 0; i < distFilesToProcess.length; i += batchSize) {
-    const batch = distFilesToProcess.slice(i, i + batchSize);
+  for (let i = 0; i < outputFilesToProcess.length; i += batchSize) {
+    const batch = outputFilesToProcess.slice(i, i + batchSize);
     await pMap(
       batch,
-      async (distFilePath) => {
+      async (outputFilePath) => {
         try {
-          const wasProcessed = await processSingleDistFile(distFilePath, options);
+          const wasProcessed = await processSingleOutputFile(outputFilePath, options);
           if (wasProcessed) {
-            result.processedFiles.push(distFilePath);
+            result.processedFiles.push(outputFilePath);
           }
         } catch (error) {
-          const errorMessage = `Error processing ${distFilePath}: ${formatError(error)}`;
+          const errorMessage = `Error processing ${outputFilePath}: ${formatError(error)}`;
           if (options.stopOnError) {
             throw new Error(errorMessage);
           }
@@ -247,7 +340,7 @@ async function findSourceFile(distFilePath) {
   }
   return null;
 }
-async function processSingleDistFile(filePath, options = {}) {
+async function processSingleOutputFile(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}`);
@@ -296,18 +389,19 @@ async function processSingleDistFile(filePath, options = {}) {
   }
   return false;
 }
-async function findDistributionFiles(sourceFilePath, dist, libName) {
+async function findOutputFiles(sourceFilePath, outputDir, libName, customOutputPaths) {
   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 outputFiles = [];
+  const allOutputPaths = { ...DEFAULT_OUTPUT_PATHS, ...customOutputPaths };
+  if (outputDir === "dist-libs" && libName) {
     const targets = await getAvailableRegistries(libName);
     for (const target of targets) {
-      const distPath = join("dist-libs", libName, target, "bin", dirPath === "." ? "" : dirPath);
+      const outputPath = join("dist-libs", libName, target, "bin", dirPath === "." ? "" : dirPath);
       let extensions;
       if (isDts && PROCESS_DTS_FILES) {
         extensions = [".d.ts"];
@@ -316,16 +410,16 @@ async function findDistributionFiles(sourceFilePath, dist, libName) {
       } 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);
+      for (const outputExt of extensions) {
+        const outputFile = path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+        if (await fs.pathExists(outputFile)) {
+          outputFiles.push(outputFile);
         }
       }
     }
   } else {
-    const basePath = DIST_PATHS[dist];
-    const distPath = path.join(basePath, dirPath === "." ? "" : dirPath);
+    const basePath = allOutputPaths[outputDir] || outputDir;
+    const outputPath = path.join(basePath, dirPath === "." ? "" : dirPath);
     let extensions;
     if (isDts && PROCESS_DTS_FILES) {
       extensions = [".d.ts"];
@@ -334,14 +428,14 @@ async function findDistributionFiles(sourceFilePath, dist, libName) {
     } 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);
+    for (const outputExt of extensions) {
+      const outputFile = path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+      if (await fs.pathExists(outputFile)) {
+        outputFiles.push(outputFile);
       }
     }
   }
-  return distFiles;
+  return outputFiles;
 }
 const SPELL_REGEX = /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i;
 let spellImplementationPaths = null;
@@ -472,3 +566,62 @@ async function* walkDirectoryTree(dir) {
     throw new Error(errorMessage);
   }
 }
+export async function getFilesWithMagicSpells(dirs, options = {}) {
+  const { stopOnError = false, excludeSpellImplementation = true } = options;
+  const filesWithSpells = [];
+  try {
+    await pMap(
+      dirs,
+      async (dir) => {
+        const fullPath = path.join(process.cwd(), dir);
+        if (!await fs.pathExists(fullPath)) {
+          const error = `Directory does not exist: ${dir}`;
+          if (stopOnError) {
+            throw new Error(error);
+          }
+          relinka("warn", error);
+          return;
+        }
+        for await (const filePath of walkDirectoryTree(fullPath)) {
+          if (await isBinaryExt(filePath)) {
+            continue;
+          }
+          const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+          if (excludeSpellImplementation && await isSpellImplementationFile(projectRel)) {
+            continue;
+          }
+          try {
+            const content = await fs.readFile(filePath, "utf8");
+            const lines = content.split(/\r?\n/);
+            const spellLines = [];
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i];
+              if (line && /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i.test(line)) {
+                spellLines.push(i + 1);
+              }
+            }
+            if (spellLines.length > 0) {
+              filesWithSpells.push({
+                path: filePath,
+                spellLines
+              });
+            }
+          } catch (error) {
+            const errorMessage = `Failed to read file ${filePath}: ${formatError(error)}`;
+            if (stopOnError) {
+              throw new Error(errorMessage);
+            }
+            relinka("error", errorMessage);
+          }
+        }
+      },
+      {
+        concurrency: 4,
+        stopOnError
+      }
+    );
+    return filesWithSpells;
+  } catch (error) {
+    throw new Error(`Failed to scan directories: ${formatError(error)}`);
+  }
+}

package/bin/libs/sdk/sdk-impl/{spell → magic}/spells.d.ts

@@ -6,6 +6,7 @@
  *   // <dler-replace-line-to `NEW CONTENT` [if 'cond'] [else 'alt']>
  *   // <dler-remove-line>
  *   // <dler-remove-file>
+ *   // <dler-remove-comment>
  *
  * A directive is recognised whether written as:
  *   // <dler-…>                or
@@ -23,7 +24,21 @@ export interface SpellOutcome {
     removeLine: boolean;
     removeFile: boolean;
 }
-export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file";
+export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file" | "dler-remove-comment";
+export interface SpellInfo {
+    /** The name of the spell directive */
+    name: SpellDirective;
+    /** A short description of what the spell does */
+    description: string;
+    /** Example usage of the spell */
+    example: string;
+    /** Additional notes about the spell's behavior */
+    notes?: string;
+}
+/**
+ * Returns information about all available magic directives
+ */
+export declare function getAvailableSpells(): SpellInfo[];
 /**
  * Evaluates a single line for magic directives and returns the effect.
  * If no directive is present, returns neutral outcome.

package/bin/libs/sdk/sdk-impl/{spell → magic}/spells.js

@@ -4,6 +4,34 @@ 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 getAvailableSpells() {
+  return [
+    {
+      name: "dler-replace-line-to",
+      description: "Replaces the current line with new content, optionally based on a condition",
+      example: "// <dler-replace-line-to `export const version = \"1.0.0\";` if 'current file path starts with dist-npm'>",
+      notes: "If condition is not met and else content is provided, uses else content. Otherwise keeps original line. Also supports @ts-expect-error prefix."
+    },
+    {
+      name: "dler-remove-line",
+      description: "Removes the current line from the output",
+      example: "// <dler-remove-line>",
+      notes: "Also supports @ts-expect-error prefix."
+    },
+    {
+      name: "dler-remove-file",
+      description: "Removes the entire file from the output",
+      example: "// <dler-remove-file>",
+      notes: "This directive should be placed at the top of the file for clarity. Also supports @ts-expect-error prefix."
+    },
+    {
+      name: "dler-remove-comment",
+      description: "Removes the current line if it's a comment",
+      example: "// <dler-remove-comment>",
+      notes: "Only removes the line if it starts with //. Useful for cleaning up comments in output files. Also supports @ts-expect-error prefix."
+    }
+  ];
+}
 export function evaluateMagicDirective(line, ctx) {
   const match = line.match(SPELL_REGEX);
   if (!match) return NO_OP;
@@ -26,6 +54,13 @@ export function evaluateMagicDirective(line, ctx) {
       return { removeLine: true, removeFile: false };
     }
     /* -------------------------------------------------------------- */
+    /* dler-remove-comment                                            */
+    /* -------------------------------------------------------------- */
+    case "dler-remove-comment": {
+      const isComment = line.trim().startsWith("//");
+      return { removeLine: isComment, removeFile: false };
+    }
+    /* -------------------------------------------------------------- */
     /* dler-replace-line-to                                           */
     /* -------------------------------------------------------------- */
     case "dler-replace-line-to": {
@@ -49,7 +84,12 @@ export function evaluateMagicDirective(line, ctx) {
 }
 const NO_OP = { removeLine: false, removeFile: false };
 function isValidMagicDirective(directive) {
-  return ["dler-replace-line-to", "dler-remove-line", "dler-remove-file"].includes(directive);
+  return [
+    "dler-replace-line-to",
+    "dler-remove-line",
+    "dler-remove-file",
+    "dler-remove-comment"
+  ].includes(directive);
 }
 function parseReplacementDirective(body) {
   const parts = {

package/bin/libs/sdk/sdk-impl/rules/reliverse/missing-deps/deps-types.d.ts

@@ -1,4 +1,4 @@
-export type FileType = ".js" | ".jsx" | ".ts" | ".tsx";
+export type MissingDepsFileType = ".js" | ".jsx" | ".ts" | ".tsx";
 export interface PackageJson {
     name?: string;
     dependencies?: Record<string, string>;