@reliverse/dler 1.7.22 → 1.7.23

package/bin/app/inject/impl.js

@@ -1,159 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { execa } from "execa";
-function parseCommand(command) {
-  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
-  const args = [];
-  let match;
-  while (regex.exec(command) !== null) {
-    match = regex.exec(command);
-    if (match) {
-      const value = match[1] ?? match[2] ?? match[3];
-      if (value) {
-        args.push(value);
-      }
-    }
-  }
-  const cmd = args.shift() ?? "";
-  return { cmd, args };
-}
-async function parseLinesFile(linesFile) {
-  const fileContents = await fs.readFile(linesFile, "utf8");
-  const splitted = fileContents.split(/\r?\n/);
-  const results = [];
-  for (const rawLine of splitted) {
-    const trimmed = rawLine.trim();
-    if (!trimmed) continue;
-    const firstMatch = trimmed.match(/^(\d+)\s+(.+?):(\d+)$/);
-    if (firstMatch?.[2] && firstMatch?.[3]) {
-      results.push({
-        filePath: firstMatch[2],
-        lineNumber: Number.parseInt(firstMatch[3], 10)
-      });
-      continue;
-    }
-    const secondMatch = trimmed.match(/^(.+?):(\d+)$/);
-    if (secondMatch?.[1] && secondMatch?.[2]) {
-      results.push({
-        filePath: secondMatch[1],
-        lineNumber: Number.parseInt(secondMatch[2], 10)
-      });
-    } else {
-      relinka("warn", `Line doesn't match expected format: ${trimmed}`);
-    }
-  }
-  return results;
-}
-async function runTscAndParseErrors(tscCommand, tscPaths) {
-  try {
-    const { cmd, args: cmdArgs } = parseCommand(tscCommand);
-    if (tscPaths?.length) {
-      cmdArgs.push(...tscPaths);
-    }
-    const subprocess = await execa(cmd, cmdArgs, { all: true, reject: false });
-    const combinedOutput = subprocess.all ?? "";
-    return parseErrorOutput(combinedOutput);
-  } catch (error) {
-    if (error && typeof error === "object" && "all" in error) {
-      const combined = error.all ?? "";
-      if (!combined) {
-        relinka("log", "TSC returned no error lines. Possibly no TS errors?");
-        return [];
-      }
-      return parseErrorOutput(combined);
-    }
-    return [];
-  }
-}
-function parseErrorOutput(output) {
-  const results = [];
-  const splitted = output.split(/\r?\n/);
-  const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
-  for (const line of splitted) {
-    const match = line.trim().match(regex);
-    if (match?.[1] && match?.[2]) {
-      const file = match[1].replace(/\\/g, "/");
-      const row = Number.parseInt(match[2], 10);
-      if (row > 0) {
-        results.push({ filePath: file, lineNumber: row });
-      }
-    }
-  }
-  return results;
-}
-function isWithin(filePath, dirs) {
-  const absFile = path.resolve(filePath);
-  return dirs.some((dir) => {
-    const absDir = path.resolve(dir);
-    const normalizedDir = absDir.endsWith(path.sep) ? absDir : absDir + path.sep;
-    return absFile.startsWith(normalizedDir);
-  });
-}
-async function injectCommentIntoFiles(linesRecords, commentText) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const rec of linesRecords) {
-    const lines = byFile.get(rec.filePath) ?? [];
-    lines.push(rec.lineNumber);
-    byFile.set(rec.filePath, lines);
-  }
-  for (const [filePath, lineNums] of byFile.entries()) {
-    lineNums.sort((a, b) => b - a);
-    const absPath = path.resolve(filePath);
-    relinka("log", `Injecting into ${absPath} at lines: ${lineNums.join(", ")}`);
-    try {
-      const original = await fs.readFile(absPath, "utf8");
-      const splitted = original.split(/\r?\n/);
-      for (const ln of lineNums) {
-        if (ln <= splitted.length) {
-          splitted.splice(ln - 1, 0, commentText);
-        } else {
-          relinka("warn", `Line ${ln} exceeds file length for ${absPath}`);
-        }
-      }
-      const newContent = splitted.join("\n");
-      await fs.writeFile(absPath, newContent, "utf8");
-    } catch (error) {
-      relinka("error", `Failed editing ${filePath}: ${error}`);
-    }
-  }
-}
-export async function useTsExpectError(args) {
-  const finalComment = args.comment ?? "// @ts-expect-error TODO: fix ts";
-  const tscCommand = "tsc --project ./tsconfig.json --noEmit";
-  const lines = [];
-  const usedAuto = args.files.some((item) => item.toLowerCase() === "auto");
-  if (usedAuto) {
-    relinka("log", "Running TSC to discover error lines...");
-    try {
-      const discovered = await runTscAndParseErrors(tscCommand, args.tscPaths);
-      if (args.tscPaths?.length) {
-        const filtered = discovered.filter(
-          (rec) => args.tscPaths ? isWithin(rec.filePath, args.tscPaths) : true
-        );
-        lines.push(...filtered);
-      } else {
-        lines.push(...discovered);
-      }
-    } catch (error) {
-      relinka("error", `Failed running tsc: ${error}`);
-      process.exit(1);
-    }
-  }
-  for (const item of args.files) {
-    if (item.toLowerCase() === "auto") continue;
-    try {
-      const recs = await parseLinesFile(item);
-      lines.push(...recs);
-    } catch (error) {
-      relinka("error", `Failed reading lines file ${item}: ${error}`);
-    }
-  }
-  if (lines.length === 0) {
-    relinka("error", "No references found. Nothing to do.");
-    relinka("error", "Lines: ", JSON.stringify(lines));
-    process.exit(1);
-  }
-  await injectCommentIntoFiles(lines, finalComment);
-  relinka("success", "All lines processed successfully.");
-}

package/bin/app/spell/cmd.js

@@ -1,47 +0,0 @@
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { applyMagicSpells } from "../../libs/sdk/sdk-impl/spell/applyMagicSpells.js";
-import { formatError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
-export default defineCommand({
-  args: defineArgs({
-    targets: {
-      type: "array",
-      description: "Distribution types to process",
-      required: true
-    },
-    lib: {
-      type: "string",
-      description: "Library to process (e.g. cfg, sdk, etc) (for usage with `dist-libs`)"
-    },
-    concurrency: {
-      type: "number",
-      description: "Number of files to process in parallel"
-    },
-    batchSize: {
-      type: "number",
-      description: "Number of files to process in each batch"
-    },
-    stopOnError: {
-      type: "boolean",
-      description: "Stop processing on first error",
-      default: true
-    }
-  }),
-  async run({ args }) {
-    const { targets, lib, concurrency, batchSize, stopOnError } = args;
-    if (lib && !targets?.includes("dist-libs")) {
-      throw new Error("The 'lib' parameter can only be used with 'dist-libs' target");
-    }
-    try {
-      const finalTargets = targets?.map(
-        (target) => target === "dist-libs" && lib ? `${target}/${lib}` : target
-      ) ?? [];
-      await applyMagicSpells(finalTargets, {
-        concurrency,
-        batchSize,
-        stopOnError
-      });
-    } catch (error) {
-      throw new Error(`\u274C Processing failed: ${formatError(error)}`);
-    }
-  }
-});

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

@@ -1,38 +0,0 @@
-/**
- * Spell runner – walks a directory tree, finds
- * magic-comment directives and executes them.
- *
- * Usage example:
- *   await applyMagicSpells(["dist-jsr"]);
- *   await applyMagicSpells(["dist-libs/sdk"]);
- *   await applyMagicSpells(["dist-npm", "dist-jsr", "dist-libs"]);
- */
-export interface ApplyMagicSpellsOptions {
-    /** Absolute or cwd-relative root directory to process */
-    dir: string;
-    /** Number of files to process in parallel */
-    concurrency?: number;
-    /** Number of files to process in each batch */
-    batchSize?: number;
-    /** Whether to stop on first error */
-    stopOnError?: boolean;
-    /** Whether to copy files from src before processing */
-    copyFileWithDirectivesFromSrcBeforeProcessing?: boolean;
-}
-export interface ApplyMagicSpellsResult {
-    /** All processed files */
-    processedFiles: string[];
-}
-/**
- * Processes files in specified distribution directories by applying magic directives
- * First scans src directory for files with magic directives, then processes corresponding dist files
- * @param targets Array of distribution targets in format "dist-npm", "dist-jsr", "dist-libs" or "dist-libs/lib-name"
- * @param options Configuration options for processing
- * @returns Object containing arrays of processed files and processed .d.ts files
- */
-export declare function applyMagicSpells(targets: string[], options?: Partial<ApplyMagicSpellsOptions>): Promise<ApplyMagicSpellsResult>;
-/**
- * Gets all available registries across all libraries
- * @returns Array of unique registry names found across all libraries
- */
-export declare function getAllAvailableRegistries(): Promise<string[]>;