@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/inject/inject-impl-mod.js

@@ -1,716 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "@reliverse/pathkit";
-import {
-  createTransformer,
-  insertAt,
-  readAndTransform,
-  remove
-} from "../transform/transform-impl-mod.js";
-import { isBinaryExt } from "../utils/binary.js";
-const countNewlines = (str) => (str.match(/\n/g) || []).length;
-const validateLineColumn = (line, column, based = "1-based") => {
-  const minValue = based === "0-based" ? 0 : 1;
-  if (!Number.isInteger(line) || line < minValue) {
-    return `Line number must be a ${based === "0-based" ? "non-negative" : "positive"} integer (${based})`;
-  }
-  if (column !== void 0 && (!Number.isInteger(column) || column < minValue)) {
-    return `Column number must be a ${based === "0-based" ? "non-negative" : "positive"} integer when provided (${based})`;
-  }
-  return null;
-};
-const validateInjectionPositioning = (injection) => {
-  const positioningMethods = [
-    injection.location ? "location" : null,
-    injection.injectBefore ? "injectBefore" : null,
-    injection.injectAfter ? "injectAfter" : null
-  ].filter(Boolean);
-  if (positioningMethods.length === 0) {
-    return "Must specify exactly one of: location, injectBefore, or injectAfter";
-  }
-  if (positioningMethods.length > 1) {
-    return `Cannot use multiple positioning methods. Found: ${positioningMethods.join(", ")}`;
-  }
-  return null;
-};
-const getLineColumnPosition = (content, line, column, based = "1-based") => {
-  const lines = content.split(/\r?\n/);
-  const zeroBasedLine = based === "0-based" ? line : line - 1;
-  const zeroBasedColumn = column !== void 0 ? based === "0-based" ? column : column - 1 : void 0;
-  if (zeroBasedLine >= lines.length || zeroBasedLine < 0) {
-    const displayLine = based === "0-based" ? line : line;
-    throw new Error(
-      `Line ${displayLine} does not exist (file has ${lines.length} lines, ${based})`
-    );
-  }
-  let position = 0;
-  const hasCarriageReturn = content.includes("\r\n");
-  for (let i = 0; i < zeroBasedLine; i++) {
-    const currentLine = lines[i];
-    if (currentLine === void 0) continue;
-    position += currentLine.length + (hasCarriageReturn ? 2 : 1);
-  }
-  if (zeroBasedColumn !== void 0) {
-    const targetLine = lines[zeroBasedLine];
-    if (targetLine === void 0) {
-      const displayLine = based === "0-based" ? line : line;
-      throw new Error(`Line ${displayLine} does not exist (${based})`);
-    }
-    if (zeroBasedColumn > targetLine.length) {
-      const displayLine = based === "0-based" ? line : line;
-      const displayColumn = based === "0-based" ? column : column;
-      throw new Error(
-        `Column ${displayColumn} does not exist in line ${displayLine} (line has ${targetLine.length} characters, ${based})`
-      );
-    }
-    position += zeroBasedColumn;
-  } else {
-    const lastLine = lines[zeroBasedLine];
-    if (lastLine === void 0) {
-      const displayLine = based === "0-based" ? line : line;
-      throw new Error(`Line ${displayLine} does not exist (${based})`);
-    }
-    position += lastLine.length;
-  }
-  return position;
-};
-const normalizeContent = (content) => {
-  if (Array.isArray(content)) {
-    return content.join("\n");
-  }
-  return content;
-};
-const normalizeTargetStrings = (target, arrayBeforeAfter = "array-means-multiline") => {
-  if (typeof target === "string") {
-    return [target];
-  }
-  if (arrayBeforeAfter === "array-means-multiline") {
-    return [target.join("\n")];
-  }
-  return target;
-};
-const findInjectionPositions = (content, targets, mode) => {
-  const positions = [];
-  for (const target of targets) {
-    let searchStart = 0;
-    let foundIndex = content.indexOf(target, searchStart);
-    while (foundIndex !== -1) {
-      const position = mode === "before" ? foundIndex : foundIndex + target.length;
-      positions.push({ position, target });
-      searchStart = foundIndex + target.length;
-      foundIndex = content.indexOf(target, searchStart);
-    }
-  }
-  return positions.sort((a, b) => b.position - a.position);
-};
-const getRemovalRange = (fileContent, line, column, contentToRemove, based = "1-based", strict = false) => {
-  const startPosition = getLineColumnPosition(fileContent, line, column, based);
-  const actualContent = fileContent.slice(startPosition, startPosition + contentToRemove.length);
-  if (actualContent !== contentToRemove) {
-    if (!strict) {
-      return null;
-    }
-    const displayLine = based === "0-based" ? line : line;
-    const displayColumn = column !== void 0 ? based === "0-based" ? column : column : void 0;
-    throw new Error(
-      `Content mismatch at line ${displayLine}${displayColumn !== void 0 ? `, column ${displayColumn}` : ""} (${based}). Expected: "${contentToRemove}", Found: "${actualContent}"`
-    );
-  }
-  return {
-    start: startPosition,
-    end: startPosition + contentToRemove.length
-  };
-};
-const getBeforeAfterRemovalPositions = (content, targets, injectedContent, mode, strict = false) => {
-  const positions = [];
-  for (const target of targets) {
-    let searchStart = 0;
-    let foundIndex = content.indexOf(target, searchStart);
-    while (foundIndex !== -1) {
-      let contentStart;
-      let contentEnd;
-      if (mode === "before") {
-        contentEnd = foundIndex;
-        contentStart = contentEnd - injectedContent.length;
-      } else {
-        contentStart = foundIndex + target.length;
-        contentEnd = contentStart + injectedContent.length;
-      }
-      if (contentStart >= 0 && contentEnd <= content.length) {
-        const actualContent = content.slice(contentStart, contentEnd);
-        if (actualContent === injectedContent) {
-          positions.push({ start: contentStart, end: contentEnd });
-        } else if (strict) {
-          throw new Error(
-            `Content mismatch near target "${target}". Expected: "${injectedContent}", Found: "${actualContent}"`
-          );
-        }
-      } else if (strict) {
-        throw new Error(`Injected content not found ${mode} target "${target}"`);
-      }
-      searchStart = foundIndex + target.length;
-      foundIndex = content.indexOf(target, searchStart);
-    }
-  }
-  if (positions.length === 0 && strict) {
-    throw new Error("No injected content found to remove");
-  }
-  if (positions.length === 0) {
-    return null;
-  }
-  return positions.sort((a, b) => b.start - a.start);
-};
-const validateFile = async (filePath) => {
-  try {
-    await fs.access(filePath);
-  } catch {
-    return `File does not exist: ${filePath}`;
-  }
-  if (await isBinaryExt(filePath)) {
-    return `Cannot inject into binary file: ${filePath}`;
-  }
-  return null;
-};
-const createResult = (success, filePath, injection, transformer, error, logCode, matchesFound) => {
-  const result = {
-    success,
-    filePath
-  };
-  if (injection.location) {
-    result.location = injection.location;
-  }
-  if (injection.injectBefore) {
-    result.injectBefore = injection.injectBefore;
-  }
-  if (injection.injectAfter) {
-    result.injectAfter = injection.injectAfter;
-  }
-  if (error) {
-    result.error = error;
-  }
-  if (transformer) {
-    if (logCode) {
-      result.code = transformer.current();
-    }
-    result.hasChanged = transformer.hasChanged();
-  }
-  if (matchesFound !== void 0) {
-    result.matchesFound = matchesFound;
-  }
-  return result;
-};
-export const injectAtLocation = async (injection, options = {}) => {
-  const { filePath, location, content, injectBefore, injectAfter } = injection;
-  const {
-    revert = false,
-    based = "1-based",
-    logCode = false,
-    strict = false,
-    arrayBeforeAfter = "array-means-multiline"
-  } = options;
-  try {
-    const positioningError = validateInjectionPositioning(injection);
-    if (positioningError) {
-      return createResult(false, filePath, injection, void 0, positioningError, logCode);
-    }
-    if (location) {
-      const validationError = validateLineColumn(location.line, location.column, based);
-      if (validationError) {
-        return createResult(false, filePath, injection, void 0, validationError, logCode);
-      }
-    }
-    const fileError = await validateFile(filePath);
-    if (fileError) {
-      return createResult(false, filePath, injection, void 0, fileError, logCode);
-    }
-    let matchesFound = 0;
-    const result = await readAndTransform(filePath, (transformer2) => {
-      try {
-        const currentContent = transformer2.current();
-        const normalizedContent = normalizeContent(content);
-        if (location) {
-          if (revert) {
-            const removalRange = getRemovalRange(
-              currentContent,
-              location.line,
-              location.column,
-              normalizedContent,
-              based,
-              strict
-            );
-            if (removalRange === null) {
-              return transformer2;
-            }
-            const { start, end } = removalRange;
-            return remove(transformer2, start, end);
-          }
-          const position = getLineColumnPosition(
-            currentContent,
-            location.line,
-            location.column,
-            based
-          );
-          return insertAt(transformer2, position, normalizedContent);
-        }
-        if (injectBefore || injectAfter) {
-          const target = injectBefore || injectAfter;
-          if (!target) {
-            throw new Error("Invalid injection configuration");
-          }
-          const mode = injectBefore ? "before" : "after";
-          const targets = normalizeTargetStrings(target, arrayBeforeAfter);
-          if (revert) {
-            const removalPositions = getBeforeAfterRemovalPositions(
-              currentContent,
-              targets,
-              normalizedContent,
-              mode,
-              strict
-            );
-            if (removalPositions === null) {
-              return transformer2;
-            }
-            let modifiedTransformer2 = transformer2;
-            for (const { start, end } of removalPositions) {
-              modifiedTransformer2 = remove(modifiedTransformer2, start, end);
-              matchesFound++;
-            }
-            return modifiedTransformer2;
-          }
-          const positions = findInjectionPositions(currentContent, targets, mode);
-          matchesFound = positions.length;
-          let modifiedTransformer = transformer2;
-          for (const { position } of positions) {
-            modifiedTransformer = insertAt(modifiedTransformer, position, normalizedContent);
-          }
-          return modifiedTransformer;
-        }
-        throw new Error("Invalid injection configuration");
-      } catch (error) {
-        const operation = revert ? "Revert" : "Injection";
-        throw new Error(
-          `${operation} failed: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    });
-    if (options.writeToFile !== false) {
-      await fs.writeFile(filePath, result.code);
-    }
-    if (options.generateSourceMap && options.sourceMapPath) {
-      const originalContent = await fs.readFile(filePath, "utf-8");
-      const transformer2 = createTransformer(originalContent);
-      const normalizedContent = normalizeContent(content);
-      let transformedContent;
-      if (location) {
-        if (revert) {
-          const removalRange = getRemovalRange(
-            originalContent,
-            location.line,
-            location.column,
-            normalizedContent,
-            based,
-            strict
-          );
-          if (removalRange === null) {
-            transformedContent = transformer2;
-          } else {
-            const { start, end } = removalRange;
-            transformedContent = remove(transformer2, start, end);
-          }
-        } else {
-          const position = getLineColumnPosition(
-            originalContent,
-            location.line,
-            location.column,
-            based
-          );
-          transformedContent = insertAt(transformer2, position, normalizedContent);
-        }
-      } else if (injectBefore || injectAfter) {
-        const target = injectBefore || injectAfter;
-        if (!target) {
-          throw new Error("Invalid injection configuration");
-        }
-        const mode = injectBefore ? "before" : "after";
-        const targets = normalizeTargetStrings(target, arrayBeforeAfter);
-        if (revert) {
-          const removalPositions = getBeforeAfterRemovalPositions(
-            originalContent,
-            targets,
-            normalizedContent,
-            mode,
-            strict
-          );
-          transformedContent = transformer2;
-          if (removalPositions) {
-            for (const { start, end } of removalPositions) {
-              transformedContent = remove(transformedContent, start, end);
-            }
-          }
-        } else {
-          const positions = findInjectionPositions(originalContent, targets, mode);
-          transformedContent = transformer2;
-          for (const { position } of positions) {
-            transformedContent = insertAt(transformedContent, position, normalizedContent);
-          }
-        }
-      } else {
-        transformedContent = transformer2;
-      }
-      const map = transformedContent.generateMap({
-        source: filePath,
-        file: options.sourceMapPath,
-        includeContent: true
-      });
-      await fs.writeFile(options.sourceMapPath, map.toString());
-    }
-    const transformer = createTransformer(result.code);
-    return createResult(true, filePath, injection, transformer, void 0, logCode, matchesFound);
-  } catch (error) {
-    return createResult(
-      false,
-      filePath,
-      injection,
-      void 0,
-      error instanceof Error ? error.message : String(error),
-      logCode
-    );
-  }
-};
-export const injectMultiple = async (injections, options = {}) => {
-  const results = [];
-  const {
-    revert = false,
-    based = "1-based",
-    logCode = false,
-    strict = false,
-    arrayBeforeAfter = "array-means-multiline"
-  } = options;
-  const injectionsByFile = /* @__PURE__ */ new Map();
-  for (const injection of injections) {
-    const fileInjections = injectionsByFile.get(injection.filePath) || [];
-    fileInjections.push(injection);
-    injectionsByFile.set(injection.filePath, fileInjections);
-  }
-  for (const [filePath, fileInjections] of injectionsByFile) {
-    try {
-      const fileError = await validateFile(filePath);
-      if (fileError) {
-        for (const injection of fileInjections) {
-          results.push(createResult(false, filePath, injection, void 0, fileError, logCode));
-        }
-        continue;
-      }
-      const validationErrors = [];
-      for (const injection of fileInjections) {
-        const positioningError = validateInjectionPositioning(injection);
-        if (positioningError) {
-          validationErrors.push({ injection, error: positioningError });
-          continue;
-        }
-        if (injection.location) {
-          const validationError = validateLineColumn(
-            injection.location.line,
-            injection.location.column,
-            based
-          );
-          if (validationError) {
-            validationErrors.push({ injection, error: validationError });
-          }
-        }
-      }
-      for (const { injection, error } of validationErrors) {
-        results.push(createResult(false, filePath, injection, void 0, error, logCode));
-      }
-      const validInjections = fileInjections.filter(
-        (inj) => !validationErrors.some((ve) => ve.injection === inj)
-      );
-      if (validInjections.length === 0) {
-        continue;
-      }
-      const locationInjections = validInjections.filter((inj) => inj.location);
-      const beforeAfterInjections = validInjections.filter(
-        (inj) => inj.injectBefore || inj.injectAfter
-      );
-      let transformer = createTransformer(await fs.readFile(filePath, "utf-8"));
-      let hasAnyChanges = false;
-      const originalContent = transformer.current();
-      const allInjectionsWithPositions = [];
-      let cumulativeNewlineOffset = 0;
-      for (const injection of locationInjections) {
-        try {
-          const normalizedContent = normalizeContent(injection.content);
-          const effectiveLine = Math.max(
-            based === "0-based" ? 0 : 1,
-            injection.location.line - cumulativeNewlineOffset
-          );
-          if (revert) {
-            const removalRange = getRemovalRange(
-              originalContent,
-              effectiveLine,
-              injection.location.column,
-              normalizedContent,
-              based,
-              strict
-            );
-            if (removalRange !== null) {
-              allInjectionsWithPositions.push({
-                injection,
-                originalPosition: removalRange.start,
-                normalizedContent: `__REMOVE_${removalRange.start}_${removalRange.end}__`,
-                lineNumber: effectiveLine
-              });
-            }
-          } else {
-            const position = getLineColumnPosition(
-              originalContent,
-              effectiveLine,
-              injection.location.column,
-              based
-            );
-            allInjectionsWithPositions.push({
-              injection,
-              originalPosition: position,
-              normalizedContent,
-              lineNumber: effectiveLine
-            });
-          }
-          cumulativeNewlineOffset += countNewlines(normalizedContent);
-        } catch (error) {
-          results.push(
-            createResult(
-              false,
-              filePath,
-              injection,
-              void 0,
-              error instanceof Error ? error.message : String(error),
-              logCode
-            )
-          );
-        }
-      }
-      allInjectionsWithPositions.sort((a, b) => {
-        if (revert) {
-          return a.originalPosition - b.originalPosition;
-        }
-        return b.originalPosition - a.originalPosition;
-      });
-      for (const { injection, originalPosition, normalizedContent } of allInjectionsWithPositions) {
-        try {
-          let matchesFound = 0;
-          if (revert && normalizedContent.startsWith("__REMOVE_")) {
-            const match = normalizedContent.match(/^__REMOVE_(\d+)_(\d+)__$/);
-            if (match?.[1] && match?.[2]) {
-              const start = Number.parseInt(match[1], 10);
-              const end = Number.parseInt(match[2], 10);
-              transformer = remove(transformer, start, end);
-              matchesFound = 1;
-            }
-          } else if (!revert) {
-            transformer = insertAt(transformer, originalPosition, normalizedContent);
-            matchesFound = 1;
-          }
-          hasAnyChanges = true;
-          results.push(
-            createResult(true, filePath, injection, transformer, void 0, logCode, matchesFound)
-          );
-        } catch (error) {
-          results.push(
-            createResult(
-              false,
-              filePath,
-              injection,
-              void 0,
-              error instanceof Error ? error.message : String(error),
-              logCode
-            )
-          );
-        }
-      }
-      for (const injection of beforeAfterInjections) {
-        try {
-          const currentContent = transformer.current();
-          const normalizedContent = normalizeContent(injection.content);
-          let matchesFound = 0;
-          const target = injection.injectBefore || injection.injectAfter;
-          if (!target) {
-            throw new Error("Invalid injection configuration");
-          }
-          const mode = injection.injectBefore ? "before" : "after";
-          const targets = normalizeTargetStrings(target, arrayBeforeAfter);
-          if (revert) {
-            const removalPositions = getBeforeAfterRemovalPositions(
-              currentContent,
-              targets,
-              normalizedContent,
-              mode,
-              strict
-            );
-            if (removalPositions === null) {
-              results.push(
-                createResult(true, filePath, injection, transformer, void 0, logCode, 0)
-              );
-              continue;
-            }
-            for (const { start, end } of removalPositions) {
-              transformer = remove(transformer, start, end);
-              matchesFound++;
-            }
-          } else {
-            const positions = findInjectionPositions(currentContent, targets, mode);
-            matchesFound = positions.length;
-            for (const { position } of positions) {
-              transformer = insertAt(transformer, position, normalizedContent);
-            }
-          }
-          hasAnyChanges = true;
-          results.push(
-            createResult(true, filePath, injection, transformer, void 0, logCode, matchesFound)
-          );
-        } catch (error) {
-          results.push(
-            createResult(
-              false,
-              filePath,
-              injection,
-              void 0,
-              error instanceof Error ? error.message : String(error),
-              logCode
-            )
-          );
-        }
-      }
-      if (hasAnyChanges && options.writeToFile !== false) {
-        await fs.writeFile(filePath, transformer.current());
-      }
-      if (hasAnyChanges && options.generateSourceMap && options.sourceMapPath) {
-        const map = transformer.generateMap({
-          source: filePath,
-          file: options.sourceMapPath,
-          includeContent: true
-        });
-        const sourceMapFilename = `${path.parse(filePath).name}.map`;
-        const sourceMapPath = path.join(path.dirname(options.sourceMapPath), sourceMapFilename);
-        await fs.writeFile(sourceMapPath, map.toString());
-      }
-    } catch (error) {
-      for (const injection of fileInjections) {
-        results.push(
-          createResult(
-            false,
-            filePath,
-            injection,
-            void 0,
-            error instanceof Error ? error.message : String(error),
-            logCode
-          )
-        );
-      }
-    }
-  }
-  return results;
-};
-export const createInjection = (filePath, content, positioning) => {
-  const injection = {
-    filePath,
-    content
-  };
-  if ("line" in positioning) {
-    injection.location = {
-      line: positioning.line,
-      column: positioning.column
-    };
-  } else if ("injectBefore" in positioning) {
-    injection.injectBefore = positioning.injectBefore;
-  } else if ("injectAfter" in positioning) {
-    injection.injectAfter = positioning.injectAfter;
-  }
-  return injection;
-};
-export const validateInjection = (injection, based = "1-based") => {
-  if (!injection.filePath) {
-    return "File path is required";
-  }
-  if (!injection.content || Array.isArray(injection.content) && injection.content.length === 0) {
-    return "Content is required";
-  }
-  if (Array.isArray(injection.content)) {
-    for (const item of injection.content) {
-      if (typeof item !== "string") {
-        return "All content array items must be strings";
-      }
-    }
-  }
-  const positioningError = validateInjectionPositioning(injection);
-  if (positioningError) {
-    return positioningError;
-  }
-  if (injection.location) {
-    return validateLineColumn(injection.location.line, injection.location.column, based);
-  }
-  if (injection.injectBefore) {
-    if (typeof injection.injectBefore !== "string" && !Array.isArray(injection.injectBefore)) {
-      return "injectBefore must be a string or string array";
-    }
-    if (Array.isArray(injection.injectBefore)) {
-      for (const item of injection.injectBefore) {
-        if (typeof item !== "string") {
-          return "All injectBefore array items must be strings";
-        }
-      }
-      if (injection.injectBefore.length === 0) {
-        return "injectBefore array cannot be empty";
-      }
-    }
-  }
-  if (injection.injectAfter) {
-    if (typeof injection.injectAfter !== "string" && !Array.isArray(injection.injectAfter)) {
-      return "injectAfter must be a string or string array";
-    }
-    if (Array.isArray(injection.injectAfter)) {
-      for (const item of injection.injectAfter) {
-        if (typeof item !== "string") {
-          return "All injectAfter array items must be strings";
-        }
-      }
-      if (injection.injectAfter.length === 0) {
-        return "injectAfter array cannot be empty";
-      }
-    }
-  }
-  return null;
-};
-export const validateMultipleInjections = (injections, based = "1-based") => {
-  const errors = [];
-  for (let i = 0; i < injections.length; i++) {
-    const injection = injections[i];
-    if (!injection) continue;
-    const error = validateInjection(injection, based);
-    if (error) {
-      errors.push({ index: i, error });
-    }
-  }
-  return errors;
-};
-export const previewInjection = async (injection, options = {}) => injectAtLocation(injection, { ...options, writeToFile: false });
-export const previewMultipleInjections = async (injections, options = {}) => injectMultiple(injections, { ...options, writeToFile: false });
-export const previewRevert = async (injection, options = {}) => injectAtLocation(injection, {
-  ...options,
-  writeToFile: false,
-  revert: true
-});
-export const previewMultipleReverts = async (injections, options = {}) => injectMultiple(injections, {
-  ...options,
-  writeToFile: false,
-  revert: true
-});
-export default {
-  injectAtLocation,
-  injectMultiple,
-  createInjection,
-  validateInjection,
-  validateMultipleInjections,
-  previewInjection,
-  previewMultipleInjections,
-  previewRevert,
-  previewMultipleReverts
-};