@reliverse/dler 1.2.0

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

@@ -0,0 +1,658 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import MagicString from "magic-string";
+import pMap from "p-map";
+import path from "pathe";
+import { CONCURRENCY_DEFAULT } from "./utils-consts.js";
+const DEBUG_MODE = false;
+const CWD = process.cwd();
+const STATIC_IMPORT_REGEX = /(import|export)[\s\S]*?from\s+(['"])([^'"]+)\2/g;
+const DYNAMIC_IMPORT_REGEX = /import\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
+const DEFAULT_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+export function extractPackageName(importPath) {
+  if (!importPath || importPath.startsWith(".") || importPath.startsWith("/")) {
+    return null;
+  }
+  const match = importPath.match(/^(@[^/]+\/[^/]+|[^/]+)/);
+  return match ? match[0] : null;
+}
+function normalizeAliasPrefix(prefix) {
+  return prefix.endsWith("/") ? prefix : `${prefix}/`;
+}
+function getBareImportUrl(importStr, requireFromKeyword = false) {
+  const regex = requireFromKeyword ? /from\s+(['"])(https?:\/\/[^'"]+)\1/ : /(['"])(https?:\/\/[^'"]+)\1/;
+  const match = regex.exec(importStr);
+  return match?.[2] ?? null;
+}
+function isLibraryImport(relativePathToRoot, libName, libConfig, currentLibName) {
+  if (currentLibName && libName === currentLibName) {
+    return false;
+  }
+  const libMainDir = path.dirname(libConfig.libMainFile).replace(/\\/g, "/");
+  return relativePathToRoot.startsWith(`${libMainDir}/`);
+}
+function matchLibraryImport(relativeToRoot, libsList, currentLibName) {
+  for (const [libName, libConfig] of Object.entries(libsList)) {
+    if (libConfig?.libMainFile && isLibraryImport(relativeToRoot, libName, libConfig, currentLibName)) {
+      return libName;
+    }
+  }
+  return null;
+}
+function replaceJsExtension(importPath) {
+  if (importPath.endsWith(".js")) {
+    return `${importPath.slice(0, -3)}.ts`;
+  }
+  return importPath;
+}
+function convertAbsoluteToAlias(ip, opts) {
+  const relativePath = path.relative(opts.baseDir, ip).replace(/\\/g, "/");
+  return `${opts.aliasPrefix}${relativePath}`;
+}
+function convertAbsoluteToBare(ip) {
+  relinka(
+    "warn",
+    `Ambiguous conversion: absolute:bare for ${ip}. Using path relative to CWD.`
+  );
+  return path.relative(CWD, ip).replace(/\\/g, "/");
+}
+function convertAbsoluteToModule(ip, opts) {
+  const relativeToRoot = path.relative(CWD, ip).replace(/\\/g, "/");
+  const libName = matchLibraryImport(
+    relativeToRoot,
+    opts.libsList,
+    opts.currentLibName
+  );
+  if (libName) {
+    relinka("verbose", `Converted absolute ${ip} to module ${libName}`);
+    return libName;
+  }
+  return ip;
+}
+function convertAbsoluteToRelative(ip, opts) {
+  let relativePath = path.relative(path.dirname(opts.sourceFile), ip).replace(/\\/g, "/");
+  if (!relativePath.startsWith(".") && !path.isAbsolute(relativePath)) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
+function convertAliasToAbsolute(ip, opts) {
+  if (!ip.startsWith(opts.aliasPrefix)) return ip;
+  const subPath = ip.slice(opts.aliasPrefix.length);
+  return path.resolve(opts.baseDir, subPath);
+}
+function convertAliasToBare(ip, opts) {
+  if (!ip.startsWith(opts.aliasPrefix)) return ip;
+  const absolutePath = convertAliasToAbsolute(ip, opts);
+  return convertAbsoluteToBare(absolutePath);
+}
+function convertAliasToModule(ip, opts) {
+  if (!ip.startsWith(opts.aliasPrefix)) return ip;
+  const absolutePath = convertAliasToAbsolute(ip, opts);
+  return convertAbsoluteToModule(absolutePath, opts);
+}
+function convertAliasToRelative(ip, opts) {
+  if (!ip.startsWith(opts.aliasPrefix)) return ip;
+  const absolutePath = convertAliasToAbsolute(ip, opts);
+  return convertAbsoluteToRelative(absolutePath, opts);
+}
+function convertBareToAbsolute(ip, opts) {
+  const url = getBareImportUrl(ip);
+  if (url && opts.urlMap[url]) {
+    const localPath = opts.urlMap[url];
+    relinka("verbose", `Mapping URL ${url} to local path ${localPath}`);
+    return path.resolve(CWD, localPath);
+  }
+  const packageName = extractPackageName(ip);
+  const libConfig = packageName ? opts.libsList[packageName] : void 0;
+  if (libConfig?.libMainFile) {
+    const libEntryPoint = path.resolve(CWD, libConfig.libMainFile);
+    relinka(
+      "verbose",
+      `Mapping package ${packageName} to absolute path ${libEntryPoint}`
+    );
+    return libEntryPoint;
+  }
+  relinka(
+    "verbose",
+    `Cannot convert bare import to absolute: ${ip}. No mapping found.`
+  );
+  return ip;
+}
+function convertBareToAlias(ip, opts) {
+  const absolutePath = convertBareToAbsolute(ip, opts);
+  if (absolutePath !== ip) {
+    return convertAbsoluteToAlias(absolutePath, opts);
+  }
+  return ip;
+}
+function convertBareToDynamic(ip) {
+  relinka(
+    "warn",
+    "bare:dynamic conversion requires special handling of the full import statement."
+  );
+  return ip;
+}
+function convertBareToModule(ip, opts) {
+  const url = getBareImportUrl(ip);
+  if (url && opts.urlMap[url]) {
+    const localPath = opts.urlMap[url];
+    const absolutePath = path.resolve(CWD, localPath);
+    return convertAbsoluteToModule(absolutePath, opts);
+  }
+  const packageName = extractPackageName(ip);
+  if (packageName && opts.libsList[packageName]) {
+    relinka("verbose", `Bare import ${packageName} is already a module.`);
+    return packageName;
+  }
+  return ip;
+}
+function convertBareToRelative(ip, opts) {
+  const absolutePath = convertBareToAbsolute(ip, opts);
+  if (absolutePath !== ip) {
+    return convertAbsoluteToRelative(absolutePath, opts);
+  }
+  return ip;
+}
+function convertDynamicToAbsolute(ip, opts) {
+  return path.resolve(path.dirname(opts.sourceFile), ip);
+}
+function convertDynamicToAlias(ip, opts) {
+  const absolutePath = convertDynamicToAbsolute(ip, opts);
+  return convertAbsoluteToAlias(absolutePath, opts);
+}
+function convertDynamicToBare(ip, opts) {
+  const absolutePath = convertDynamicToAbsolute(ip, opts);
+  return convertAbsoluteToBare(absolutePath);
+}
+function convertDynamicToModule(ip, opts) {
+  const absolutePath = convertDynamicToAbsolute(ip, opts);
+  return convertAbsoluteToModule(absolutePath, opts);
+}
+function convertDynamicToRelative(ip, opts) {
+  const absolutePath = convertDynamicToAbsolute(ip, opts);
+  return convertAbsoluteToRelative(absolutePath, opts);
+}
+function convertModuleToAbsolute(ip, opts) {
+  const packageName = extractPackageName(ip);
+  const libConfig = packageName ? opts.libsList[packageName] : void 0;
+  if (!libConfig?.libMainFile) return ip;
+  const libMainDir = path.dirname(path.resolve(CWD, libConfig.libMainFile));
+  relinka(
+    "verbose",
+    `Converted module ${packageName} to absolute path ${libMainDir}`
+  );
+  return libMainDir;
+}
+function convertModuleToAlias(ip, opts) {
+  const absolutePath = convertModuleToAbsolute(ip, opts);
+  if (absolutePath !== ip) {
+    return convertAbsoluteToAlias(absolutePath, opts);
+  }
+  return ip;
+}
+function convertModuleToBare(ip, opts) {
+  const absolutePath = convertModuleToAbsolute(ip, opts);
+  if (absolutePath !== ip) {
+    return convertAbsoluteToBare(absolutePath);
+  }
+  return ip;
+}
+function convertModuleToRelative(ip, opts) {
+  const absolutePath = convertModuleToAbsolute(ip, opts);
+  if (absolutePath !== ip) {
+    return convertAbsoluteToRelative(absolutePath, opts);
+  }
+  return ip;
+}
+function convertRelativeToAbsolute(ip, opts) {
+  return path.resolve(path.dirname(opts.sourceFile), ip);
+}
+function convertRelativeToAlias(ip, opts) {
+  const absolutePath = convertRelativeToAbsolute(ip, opts);
+  return convertAbsoluteToAlias(absolutePath, opts);
+}
+function convertRelativeToBare(ip, opts) {
+  const absolutePath = convertRelativeToAbsolute(ip, opts);
+  return convertAbsoluteToBare(absolutePath);
+}
+function convertRelativeToModule(ip, opts) {
+  const absolutePath = convertRelativeToAbsolute(ip, opts);
+  return convertAbsoluteToModule(absolutePath, opts);
+}
+const conversionMapping = {
+  // Route all conversions through the specific functions defined above.
+  // The `opts` object contains all necessary context.
+  "absolute:alias": convertAbsoluteToAlias,
+  "absolute:bare": convertAbsoluteToBare,
+  "absolute:module": convertAbsoluteToModule,
+  "absolute:relative": convertAbsoluteToRelative,
+  "alias:absolute": convertAliasToAbsolute,
+  // alias:alias is identity if prefix/base match (handled in dispatcher)
+  "alias:bare": convertAliasToBare,
+  "alias:module": convertAliasToModule,
+  "alias:relative": convertAliasToRelative,
+  "bare:absolute": convertBareToAbsolute,
+  "bare:alias": convertBareToAlias,
+  "bare:dynamic": convertBareToDynamic,
+  // Placeholder, logic elsewhere
+  "bare:module": convertBareToModule,
+  "bare:relative": convertBareToRelative,
+  "dynamic:absolute": convertDynamicToAbsolute,
+  "dynamic:alias": convertDynamicToAlias,
+  "dynamic:bare": convertDynamicToBare,
+  "dynamic:module": convertDynamicToModule,
+  "dynamic:relative": convertDynamicToRelative,
+  "module:absolute": convertModuleToAbsolute,
+  "module:alias": convertModuleToAlias,
+  "module:bare": convertModuleToBare,
+  "module:relative": convertModuleToRelative,
+  "relative:absolute": convertRelativeToAbsolute,
+  "relative:alias": convertRelativeToAlias,
+  "relative:bare": convertRelativeToBare,
+  "relative:module": convertRelativeToModule
+};
+function convertSingleImportPath(fromType, toType, importPath, options) {
+  const fullOptions = {
+    baseDir: options.baseDir ?? CWD,
+    // Default baseDir if not provided
+    libsList: options.libsList ?? {},
+    sourceFile: options.sourceFile,
+    urlMap: options.urlMap ?? {},
+    strip: options.strip ?? [],
+    currentLibName: options.currentLibName,
+    // Normalize alias prefix only if provided, default to empty string
+    aliasPrefix: options.aliasPrefix ? normalizeAliasPrefix(options.aliasPrefix) : ""
+  };
+  if (fromType === toType) {
+    return importPath;
+  }
+  const conversionKey = `${fromType}:${toType}`;
+  const converter = conversionMapping[conversionKey];
+  let convertedPath;
+  if (converter) {
+    convertedPath = converter(importPath, fullOptions);
+  } else {
+    relinka(
+      "verbose",
+      `No converter found for ${conversionKey} on path "${importPath}". Returning original.`
+    );
+    convertedPath = importPath;
+  }
+  if (fullOptions.strip.length > 0 && convertedPath !== importPath) {
+    let processedPath = convertedPath;
+    for (const stripSegment of fullOptions.strip) {
+      const normalizedStripSegment = stripSegment.endsWith("/") ? stripSegment : `${stripSegment}/`;
+      if (processedPath.startsWith(normalizedStripSegment)) {
+        processedPath = processedPath.slice(normalizedStripSegment.length);
+      }
+    }
+    convertedPath = processedPath;
+  }
+  return convertedPath;
+}
+async function processFileContent(filePath, processLogic, options) {
+  const { distJsrDryRun = false, generateSourceMap = false } = options;
+  try {
+    const originalContent = await fs.readFile(filePath, "utf-8");
+    const s = new MagicString(originalContent);
+    const changesMade = await processLogic(originalContent, s);
+    if (!changesMade) {
+      return {
+        filePath,
+        message: `No changes needed for ${path.basename(filePath)}`,
+        success: true
+      };
+    }
+    const newContent = s.toString();
+    let map;
+    if (originalContent === newContent) {
+      return {
+        filePath,
+        message: `No effective changes for ${path.basename(filePath)}`,
+        success: true
+      };
+    }
+    if (generateSourceMap) {
+      map = s.generateMap({
+        file: `${path.basename(filePath)}.map`,
+        // Map file named relative to source
+        includeContent: true,
+        source: path.basename(filePath)
+        // Source file named relative to map
+      });
+    }
+    if (!distJsrDryRun) {
+      await fs.writeFile(filePath, newContent, "utf-8");
+      if (map) {
+        await fs.writeFile(`${filePath}.map`, map.toString(), "utf-8");
+      }
+    }
+    const message = `Processed ${path.basename(filePath)}${distJsrDryRun ? " (dry run)" : ""}${map ? " + sourcemap" : ""}`;
+    if (DEBUG_MODE || distJsrDryRun) {
+      relinka("verbose", message);
+    }
+    return { filePath, message, success: true };
+  } catch (error) {
+    const errorMessage = `Error processing file ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+    relinka("error", errorMessage);
+    return { filePath, message: errorMessage, success: false };
+  }
+}
+async function processDirectoryRecursively(dirPath, fileExtensions, fileProcessor, concurrency) {
+  let results = [];
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const filesToProcess = [];
+    const directoriesToRecurse = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isFile()) {
+        if (fileExtensions.some((ext) => entry.name.endsWith(ext))) {
+          filesToProcess.push(fullPath);
+        }
+      } else if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+          directoriesToRecurse.push(fullPath);
+        }
+      }
+    }
+    if (filesToProcess.length > 0) {
+      const fileResults = await pMap(filesToProcess, fileProcessor, {
+        concurrency
+      });
+      results = results.concat(fileResults);
+    }
+    for (const subDirPath of directoriesToRecurse) {
+      const subDirResults = await processDirectoryRecursively(
+        subDirPath,
+        fileExtensions,
+        fileProcessor,
+        concurrency
+      );
+      results = results.concat(subDirResults);
+    }
+  } catch (error) {
+    const errorMessage = `Error reading directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`;
+    relinka("error", errorMessage);
+  }
+  return results;
+}
+async function transformImportPathsLogic(content, s, options) {
+  let changesMade = false;
+  const { fromType, toType, filePath, ...conversionArgs } = options;
+  const converterOptions = {
+    ...conversionArgs,
+    sourceFile: filePath,
+    // Pass the absolute file path
+    strip: conversionArgs.strip ?? [],
+    // Provide default empty array
+    urlMap: conversionArgs.urlMap ?? {}
+    // Provide default empty object
+  };
+  for (const match of content.matchAll(STATIC_IMPORT_REGEX)) {
+    const fullMatch = match[0];
+    const importPath = match[3];
+    if (typeof match.index !== "number" || !importPath) continue;
+    const quoteChar = match[2];
+    const pathStartIndex = match.index + fullMatch.lastIndexOf(importPath) - 1;
+    const pathEndIndex = pathStartIndex + importPath.length + 2;
+    const bareUrl = getBareImportUrl(
+      fullMatch,
+      true
+      /* require 'from' */
+    );
+    if (fromType === "bare" && toType === "dynamic" && bareUrl) {
+      const localPath = converterOptions.urlMap?.[bareUrl];
+      if (localPath) {
+        const dynamicImportStatement = `await import(${quoteChar}${localPath}${quoteChar})`;
+        const fromIndex = fullMatch.toLowerCase().lastIndexOf(" from ");
+        if (fromIndex > 0) {
+          const replacementStart = match.index + fromIndex;
+          const replacementEnd = match.index + fullMatch.length;
+          s.overwrite(
+            replacementStart,
+            replacementEnd,
+            ` = ${dynamicImportStatement}`
+          );
+          changesMade = true;
+          if (DEBUG_MODE)
+            relinka(
+              "verbose",
+              `Converted bare URL import to dynamic: ${bareUrl} -> ${localPath}`
+            );
+        } else {
+          relinka(
+            "warn",
+            `Could not find ' from ' in statement for bare:dynamic conversion: ${fullMatch}`
+          );
+        }
+      } else {
+        relinka(
+          "verbose",
+          `No local mapping found for URL: ${bareUrl} in bare:dynamic conversion.`
+        );
+      }
+      continue;
+    }
+    const convertedPath = convertSingleImportPath(
+      fromType,
+      toType,
+      importPath,
+      converterOptions
+    );
+    if (convertedPath !== importPath) {
+      s.overwrite(pathStartIndex + 1, pathEndIndex - 1, convertedPath);
+      changesMade = true;
+      if (DEBUG_MODE)
+        relinka(
+          "verbose",
+          `Converted path: ${importPath} -> ${convertedPath} (${fromType} -> ${toType})`
+        );
+    }
+  }
+  const dynamicImportRegexLocal = new RegExp(DYNAMIC_IMPORT_REGEX.source, "g");
+  for (const match of content.matchAll(dynamicImportRegexLocal)) {
+    const fullMatch = match[0];
+    const importPath = match[2];
+    if (typeof match.index !== "number" || !importPath) continue;
+    const quoteChar = match[1];
+    const pathStartIndex = match.index + fullMatch.indexOf(quoteChar + importPath + quoteChar) + 1;
+    const pathEndIndex = pathStartIndex + importPath.length;
+    const effectiveFromType = fromType === "dynamic" ? "dynamic" : fromType;
+    const convertedPath = convertSingleImportPath(
+      effectiveFromType,
+      // Use determined 'from' type
+      toType,
+      importPath,
+      // The path string from inside import()
+      converterOptions
+    );
+    if (convertedPath !== importPath) {
+      s.overwrite(pathStartIndex, pathEndIndex, convertedPath);
+      changesMade = true;
+      if (DEBUG_MODE)
+        relinka(
+          "verbose",
+          `Converted dynamic path: ${importPath} -> ${convertedPath} (${effectiveFromType} -> ${toType})`
+        );
+    }
+  }
+  return changesMade;
+}
+async function transformJsToTsExtensionLogic(content, s) {
+  let changesMade = false;
+  const processMatches = (regex, pathGroupIndex) => {
+    const localRegex = new RegExp(
+      regex.source,
+      regex.flags.includes("g") ? regex.flags : `${regex.flags}g`
+    );
+    for (const match of content.matchAll(localRegex)) {
+      const fullMatch = match[0];
+      const importPath = match[pathGroupIndex];
+      if (typeof match.index !== "number" || !importPath) continue;
+      const replacedPath = replaceJsExtension(importPath);
+      if (replacedPath !== importPath) {
+        const quoteChar = match[pathGroupIndex - 1];
+        const pathStartIndex = match.index + fullMatch.lastIndexOf(quoteChar + importPath + quoteChar) + 1;
+        const pathEndIndex = pathStartIndex + importPath.length;
+        s.overwrite(pathStartIndex, pathEndIndex, replacedPath);
+        changesMade = true;
+        if (DEBUG_MODE)
+          relinka(
+            "verbose",
+            `Changed extension: ${importPath} -> ${replacedPath}`
+          );
+      }
+    }
+  };
+  processMatches(STATIC_IMPORT_REGEX, 3);
+  processMatches(DYNAMIC_IMPORT_REGEX, 2);
+  return changesMade;
+}
+export async function convertImportPaths(options) {
+  const {
+    baseDir: rawBaseDir,
+    fromType,
+    toType,
+    libsList,
+    aliasPrefix: rawAliasPrefix,
+    currentLibName,
+    distJsrDryRun = false,
+    fileExtensions = DEFAULT_FILE_EXTENSIONS,
+    generateSourceMap = false,
+    strip = [],
+    urlMap = {}
+  } = options;
+  if (!rawBaseDir) {
+    throw new Error("`baseDir` option is required.");
+  }
+  const baseDir = path.resolve(CWD, rawBaseDir);
+  if ((fromType === "alias" || toType === "alias") && !rawAliasPrefix) {
+    throw new Error(
+      "`aliasPrefix` is required when converting from/to 'alias' type."
+    );
+  }
+  try {
+    const stats = await fs.stat(baseDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Specified baseDir is not a directory: ${baseDir}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.code === "ENOENT") {
+      throw new Error(`Specified baseDir does not exist: ${baseDir}`);
+    }
+    throw error;
+  }
+  relinka(
+    "info",
+    `Starting import path conversion (${fromType} -> ${toType}) in directory: ${baseDir}`
+  );
+  if (distJsrDryRun) {
+    relinka("info", "Dry run mode enabled: No files will be modified.");
+  }
+  const fileProcessor = async (filePath) => {
+    return processFileContent(
+      filePath,
+      (content, s) => transformImportPathsLogic(content, s, {
+        // Pass necessary context for the transformation
+        fromType,
+        toType,
+        filePath,
+        // Pass the absolute file path
+        aliasPrefix: rawAliasPrefix,
+        // Pass raw prefix, normalization happens inside
+        baseDir,
+        // Pass the resolved absolute baseDir
+        currentLibName,
+        libsList,
+        strip,
+        urlMap
+      }),
+      { distJsrDryRun, generateSourceMap }
+      // Pass options for file writing
+    );
+  };
+  const results = await processDirectoryRecursively(
+    baseDir,
+    fileExtensions,
+    fileProcessor,
+    CONCURRENCY_DEFAULT
+  );
+  const successCount = results.filter((r) => r.success).length;
+  const changedCount = results.filter(
+    (r) => r.message.startsWith("Processed")
+  ).length;
+  const errorResults = results.filter((r) => !r.success);
+  relinka(
+    "info",
+    `Import path conversion finished. ${successCount} files processed successfully (${changedCount} modified), ${errorResults.length} errors.`
+  );
+  for (const result of errorResults) {
+    relinka("error", result.message);
+  }
+  return results;
+}
+export async function convertImportExtensionsJsToTs(options) {
+  const {
+    dirPath: rawDirPath,
+    distJsrDryRun = false,
+    fileExtensions = DEFAULT_FILE_EXTENSIONS,
+    generateSourceMap = false
+  } = options;
+  if (!rawDirPath) {
+    throw new Error("`dirPath` option is required.");
+  }
+  const absoluteDirPath = path.resolve(CWD, rawDirPath);
+  try {
+    const stats = await fs.stat(absoluteDirPath);
+    if (!stats.isDirectory()) {
+      throw new Error(
+        `Specified dirPath is not a directory: ${absoluteDirPath}`
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && error.code === "ENOENT") {
+      throw new Error(`Specified dirPath does not exist: ${absoluteDirPath}`);
+    }
+    throw error;
+  }
+  relinka(
+    "info",
+    `Starting .js -> .ts import extension conversion in directory: ${absoluteDirPath}`
+  );
+  if (distJsrDryRun) {
+    relinka("info", "Dry run mode enabled: No files will be modified.");
+  }
+  const fileProcessor = async (filePath) => {
+    return processFileContent(
+      filePath,
+      transformJsToTsExtensionLogic,
+      // Pass the dedicated logic function
+      { distJsrDryRun, generateSourceMap }
+      // Pass options for file writing
+    );
+  };
+  const results = await processDirectoryRecursively(
+    absoluteDirPath,
+    fileExtensions,
+    fileProcessor,
+    CONCURRENCY_DEFAULT
+  );
+  const successCount = results.filter((r) => r.success).length;
+  const changedCount = results.filter(
+    (r) => r.message.startsWith("Processed")
+  ).length;
+  const errorResults = results.filter((r) => !r.success);
+  relinka(
+    "info",
+    `Extension conversion finished. ${successCount} files processed successfully (${changedCount} modified), ${errorResults.length} errors.`
+  );
+  for (const result of errorResults) {
+    relinka("error", result.message);
+  }
+  return results;
+}
+export function normalizeQuotes(str) {
+  return str.replace(/['"]/g, '"');
+}

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

@@ -0,0 +1,22 @@
+export function createPerfTimer() {
+  return {
+    pausedAt: null,
+    pausedDuration: 0,
+    startTime: performance.now()
+  };
+}
+export function getElapsedPerfTime(timer) {
+  const currentPausedTime = timer.pausedAt !== null ? performance.now() - timer.pausedAt : 0;
+  return performance.now() - timer.startTime - timer.pausedDuration - currentPausedTime;
+}
+export function pausePerfTimer(timer) {
+  if (timer.pausedAt === null) {
+    timer.pausedAt = performance.now();
+  }
+}
+export function resumePerfTimer(timer) {
+  if (timer.pausedAt !== null) {
+    timer.pausedDuration += performance.now() - timer.pausedAt;
+    timer.pausedAt = null;
+  }
+}