@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/magic/magic-spells.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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>
- *   // <dler-remove-comment>
- *
- * 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" | "dler-remove-comment" | "dler-ignore-this-line";
-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.
- */
-export declare function evaluateMagicDirective(line: string, ctx: SpellEvaluationContext): SpellOutcome;

package/bin/impl/magic/magic-spells.js

@@ -1,144 +0,0 @@
-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 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 no condition is specified, replacement always applies. 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 only the comment portion containing this directive from the line",
-      example: "console.log('debug info'); // <dler-remove-comment>",
-      notes: "Removes everything from '//' to the end of the line when the comment contains this directive. The code portion before the comment is preserved. Also supports @ts-expect-error prefix."
-    },
-    {
-      name: "dler-ignore-this-line",
-      description: "Prevents any magic directives on this line from being processed",
-      example: "// <dler-remove-line> // <dler-ignore-this-line>",
-      notes: "When present on a line, all magic directives on that line are ignored and the line is kept as-is. Useful for code that contains magic directive strings that shouldn't be executed."
-    }
-  ];
-}
-export function evaluateMagicDirective(line, ctx) {
-  if (line.includes("<dler-ignore-this-line>")) {
-    return NO_OP;
-  }
-  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-remove-comment                                            */
-    /* -------------------------------------------------------------- */
-    case "dler-remove-comment": {
-      const commentIndex = line.indexOf("//");
-      if (commentIndex !== -1) {
-        const codeBeforeComment = line.substring(0, commentIndex).trimEnd();
-        return { replacement: codeBeforeComment, removeLine: false, removeFile: false };
-      }
-      return NO_OP;
-    }
-    /* -------------------------------------------------------------- */
-    /* 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;
-    }
-    /* -------------------------------------------------------------- */
-    /* dler-ignore-this-line                                          */
-    /* -------------------------------------------------------------- */
-    case "dler-ignore-this-line": {
-      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",
-    "dler-remove-comment",
-    "dler-ignore-this-line",
-    "dler-disable-agg"
-  ].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();
-  }
-  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/impl/merge/mod.d.ts

@@ -1,8 +0,0 @@
-export declare const DEFAULT_IGNORES: readonly ["**/.git/**", "**/node_modules/**"];
-export declare const DEFAULT_SEPARATOR_RAW = "\\n\\n";
-export declare const normalizeGlobPattern: (pattern: string) => string;
-export declare const parseCSV: (s: string) => any[];
-export declare const unescape: (s: string) => string;
-export declare const writeResult: (sections: string[], _separator: string, toFile: string | undefined, toStdout: boolean, dryRun: boolean, backup: boolean, generateSourceMap?: boolean) => Promise<void>;
-export declare const writeFilesPreserveStructure: (files: string[], outDir: string, preserveStructure: boolean, increment: boolean, concurrency: number, dryRun: boolean, backup: boolean) => Promise<void>;
-export declare const processSection: (raw: string, rel: string, prefix: string, pathAbove: boolean, injectPath: boolean) => string;

package/bin/impl/merge/mod.js

@@ -1,160 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { withEnhancedSpinner } from "@reliverse/rempts";
-import MagicString, { Bundle } from "magic-string";
-import pMap from "p-map";
-import {
-  checkPermissions,
-  handleCtxError,
-  sanitizeInput,
-  validateContent,
-  validateFileType,
-  validateMergeOperation,
-  validatePath
-} from "../utils/utils-security.js";
-export const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
-export const DEFAULT_SEPARATOR_RAW = "\\n\\n";
-export const normalizeGlobPattern = (pattern) => {
-  const sanitizedPattern = sanitizeInput(pattern);
-  if (!sanitizedPattern.includes("*") && !sanitizedPattern.includes("?") && !sanitizedPattern.endsWith("/")) {
-    return `${sanitizedPattern}/**/*`;
-  }
-  return sanitizedPattern;
-};
-export const parseCSV = (s) => s.split(",").map((t) => sanitizeInput(t.trim())).filter(Boolean);
-export const unescape = (s) => s.replace(/\\n/g, "\n").replace(/\\t/g, "	");
-export const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backup, generateSourceMap = false) => {
-  try {
-    const bundle = new Bundle();
-    for (const section of sections) {
-      validateContent(section, "text");
-      bundle.addSource({
-        content: new MagicString(section)
-      });
-    }
-    const content = bundle.toString();
-    const finalContent = `${content}
-`;
-    if (toStdout || !toFile) {
-      process.stdout.write(finalContent);
-      return;
-    }
-    const sanitizedPath = sanitizeInput(toFile);
-    const dir = path.dirname(sanitizedPath);
-    if (dir && dir !== ".") {
-      await fs.ensureDir(dir);
-      await checkPermissions(dir, "write");
-    }
-    if (backup && await fs.pathExists(sanitizedPath)) {
-      const backupPath = `${sanitizedPath}.${Date.now()}.bak`;
-      await checkPermissions(sanitizedPath, "read");
-      await fs.copyFile(sanitizedPath, backupPath);
-    }
-    if (!dryRun) {
-      await checkPermissions(sanitizedPath, "write");
-      validatePath(sanitizedPath, process.cwd());
-      validateFileType("text");
-      await fs.writeFile(sanitizedPath, finalContent, "utf8");
-      if (generateSourceMap) {
-        const map = bundle.generateMap({
-          file: path.basename(sanitizedPath),
-          source: sanitizedPath,
-          includeContent: true,
-          hires: true
-        });
-        const mapPath = `${sanitizedPath}.map`;
-        await fs.writeFile(mapPath, map.toString(), "utf8");
-        const sourceMapRef = `
-//# sourceMappingURL=${path.basename(mapPath)}`;
-        await fs.appendFile(sanitizedPath, sourceMapRef, "utf8");
-      }
-    }
-  } catch (error) {
-    handleCtxError(error, "writeResult");
-  }
-};
-export const writeFilesPreserveStructure = async (files, outDir, preserveStructure, increment, concurrency, dryRun, backup) => {
-  await withEnhancedSpinner(
-    {
-      text: `Copying ${files.length} files`,
-      showTiming: true,
-      successText: "File copy operation completed",
-      failText: "File copy operation failed",
-      color: "cyan"
-    },
-    async (spinner) => {
-      try {
-        if (!files?.length) {
-          throw new Error("No files provided for merge operation");
-        }
-        const cwd = process.cwd();
-        const fileNameCounts = /* @__PURE__ */ new Map();
-        spinner.updateText("Validating files");
-        await validateMergeOperation(files);
-        let processedCount = 0;
-        await pMap(
-          files,
-          async (file) => {
-            const sanitizedFile = sanitizeInput(file);
-            const relPath = preserveStructure ? path.relative(cwd, sanitizedFile) : path.basename(sanitizedFile);
-            let destPath = path.join(outDir, relPath);
-            if (increment) {
-              const dir = path.dirname(destPath);
-              const base = path.basename(destPath);
-              let dirMap = fileNameCounts.get(dir);
-              if (!dirMap) {
-                dirMap = /* @__PURE__ */ new Map();
-                fileNameCounts.set(dir, dirMap);
-              }
-              const count = dirMap.get(base) || 0;
-              if (count > 0) {
-                const extMatch = base.match(/(.*)(\.[^./\\]+)$/);
-                let newBase;
-                if (extMatch) {
-                  newBase = `${extMatch[1]}-${count + 1}${extMatch[2]}`;
-                } else {
-                  newBase = `${base}-${count + 1}`;
-                }
-                destPath = path.join(dir, newBase);
-              }
-              dirMap.set(base, count + 1);
-            }
-            await fs.ensureDir(path.dirname(destPath));
-            if (backup && await fs.pathExists(destPath)) {
-              const backupPath = `${destPath}.${Date.now()}.bak`;
-              await checkPermissions(destPath, "read");
-              await fs.copyFile(destPath, backupPath);
-            }
-            if (!dryRun) {
-              await checkPermissions(destPath, "write");
-              await fs.copyFile(sanitizedFile, destPath);
-            }
-            processedCount++;
-            spinner.setProgress(
-              processedCount,
-              files.length,
-              `Copying ${path.basename(sanitizedFile)}`
-            );
-          },
-          { concurrency }
-        );
-        return processedCount;
-      } catch (error) {
-        handleCtxError(error, "writeFilesPreserveStructure");
-        throw error;
-      }
-    }
-  );
-};
-export const processSection = (raw, rel, prefix, pathAbove, injectPath) => {
-  const magic = new MagicString(raw);
-  if (pathAbove) {
-    magic.prepend(`${prefix}${rel}
-`);
-  }
-  if (injectPath) {
-    magic.append(`
-${prefix}${rel}`);
-  }
-  return magic.toString();
-};

package/bin/impl/migrate/codemods/anything-bun.d.ts

@@ -1,5 +0,0 @@
-export declare function migrateAnythingToBun({ project, dryRun, noBackup, }: {
-    project?: string;
-    dryRun?: boolean;
-    noBackup?: boolean;
-}): Promise<void>;