@reliverse/pathkit 1.2.4 → 1.2.6

package/bin/mod.js

@@ -2,19 +2,14 @@ import fs from "node:fs/promises";
 import {
   getFileImportsExports
 } from "./impl/getFileImportsExports.js";
-const logger = (msg, debugOnly = false) => {
-  if (!debugOnly || DEBUG_MODE) {
-    const message = typeof msg === "function" ? msg() : msg;
-    console.log(`\x1B[2m${message}\x1B[0m`);
-  }
+const logger = (msg) => {
+  const message = typeof msg === "function" ? msg() : msg;
+  console.log(`\x1B[2m${message}\x1B[0m`);
 };
-const logInternal = (msg) => {
-  if (DEBUG_MODE) {
-    const message = typeof msg === "function" ? msg() : msg;
-    console.log(`\x1B[36;2m${message}\x1B[0m`);
-  }
+const logger2 = (msg) => {
+  const message = typeof msg === "function" ? msg() : msg;
+  console.log(`\x1B[36;2m${message}\x1B[0m`);
 };
-const DEBUG_MODE = true;
 const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts"];
 const SLASH = "/";
 const BACK_SLASH = "\\";
@@ -355,13 +350,20 @@ function reverseResolveAlias(path2, aliases) {
   return matches.sort((a, b) => b.length - a.length);
 }
 const findAliasMatch = (importPath, paths) => {
+  logger2(`[findAliasMatch] Processing import: ${importPath}`);
+  logger2(`  - paths: ${JSON.stringify(paths)}`);
   const firstPathKey = Object.keys(paths)[0];
-  if (!firstPathKey) return null;
+  if (!firstPathKey) {
+    logger2(`  - no paths defined`);
+    return null;
+  }
   const baseAlias = firstPathKey.replace("/*", "");
   if (importPath.startsWith("@") && !importPath.startsWith(baseAlias)) {
+    logger2(`  - skipping: npm package import`);
     return null;
   }
   if (paths[importPath]?.[0]) {
+    logger2(`  - found exact match`);
     return {
       key: importPath,
       root: importPath,
@@ -372,11 +374,15 @@ const findAliasMatch = (importPath, paths) => {
   for (const aliasKey in paths) {
     if (aliasKey.endsWith("/*")) {
       const aliasRoot = aliasKey.slice(0, -2);
+      logger2(`  - checking wildcard match for: ${aliasRoot}`);
       if (importPath === aliasRoot || importPath.startsWith(`${aliasRoot}/`)) {
         const suffix = importPath === aliasRoot ? "" : importPath.slice(aliasRoot.length + 1);
         const targetPaths = paths[aliasKey];
         if (targetPaths?.[0]) {
           const resolvedPathPattern = targetPaths[0].slice(0, -2);
+          logger2(`  - found wildcard match`);
+          logger2(`    - suffix: ${suffix}`);
+          logger2(`    - resolvedPathPattern: ${resolvedPathPattern}`);
           return {
             key: aliasKey,
             root: aliasRoot,
@@ -387,6 +393,7 @@ const findAliasMatch = (importPath, paths) => {
       }
     }
   }
+  logger2(`  - no match found`);
   return null;
 };
 const toRelativeImport = (absPath, fromDir) => {
@@ -428,19 +435,33 @@ async function convertStringAliasRelative({
   pathPattern,
   targetDir
 }) {
+  logger2(`[convertStringAliasRelative] Processing import: ${importPath}`);
+  logger2(`  - importerFile: ${importerFile}`);
+  logger2(`  - pathPattern: ${pathPattern}`);
+  logger2(`  - targetDir: ${targetDir}`);
   const baseAlias = pathPattern.replace("/*", "");
   if (importPath.startsWith("@") && !importPath.startsWith(baseAlias)) {
+    logger2(`  - skipping: npm package import`);
     return importPath;
   }
   const paths = { [pathPattern]: ["./*"] };
   const importerDir = dirname(importerFile);
   const match = findAliasMatch(importPath, paths);
-  if (!match) return importPath;
+  if (!match) {
+    logger2(`  - no alias match found`);
+    return importPath;
+  }
+  logger2(`  - found alias match: ${JSON.stringify(match)}`);
   const absPath = resolve(targetDir, match.resolvedPath, match.suffix);
+  logger2(`  - resolved absolute path: ${absPath}`);
   const resolvedFile = await resolveFileWithExtensions(absPath);
+  logger2(`  - resolved file with extensions: ${resolvedFile || "not found"}`);
   const relPath = toRelativeImport(resolvedFile || absPath, importerDir);
+  logger2(`  - relative path: ${relPath}`);
   const originalExt = extname(importPath);
-  return getTargetExtension(relPath, originalExt);
+  const result = getTargetExtension(relPath, originalExt);
+  logger2(`  - final result: ${result}`);
+  return result;
 }
 function replaceAllInString(original, searchValue, replaceValue) {
   let currentPosition = 0;
@@ -464,32 +485,50 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
   const matches = Array.from(content.matchAll(IMPORT_REGEX));
   const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
   const baseAlias = aliasToReplace.replace("/*", "");
+  logger2(`[processFile] Processing file: ${filePath}`);
+  logger2(`  - normalizedAlias: ${normalizedAlias}`);
+  logger2(`  - baseAlias: ${baseAlias}`);
+  logger2(`  - found ${matches.length} import statements`);
   for (const match of matches) {
     const originalQuote = match[1];
     const importPath = match[2];
     if (!importPath) continue;
+    logger2(`  Processing import: ${importPath}`);
     if (!importPath.startsWith(baseAlias)) {
+      logger2(`  - skipping: import doesn't start with ${baseAlias}`);
       continue;
     }
     const importExt = extname(importPath);
     const shouldProcess = pathExtFilter === "js" && importExt === ".js" || pathExtFilter === "ts" && importExt === ".ts" || pathExtFilter === "none" && importExt === "" || pathExtFilter === "js-ts-none";
-    if (!shouldProcess) continue;
+    if (!shouldProcess) {
+      logger2(`  - skipping: doesn't match pathExtFilter ${pathExtFilter}`);
+      continue;
+    }
+    logger2(`  - converting alias to relative path...`);
     const relPath = await convertStringAliasRelative({
       importPath,
       importerFile: filePath,
       pathPattern: normalizedAlias,
       targetDir
     });
+    logger2(`  - original path: ${importPath}`);
+    logger2(`  - converted to: ${relPath}`);
     const finalPath = pathExtFilter === "none" ? relPath.replace(/\.(ts|js|tsx|jsx|mjs|cjs)$/, "") : relPath;
     if (importPath !== finalPath) {
       changes.push({ from: importPath, to: finalPath });
       const searchString = `${originalQuote}${importPath}${originalQuote}`;
       const replacementString = `${originalQuote}${finalPath}${originalQuote}`;
       updated = replaceAllInString(updated, searchString, replacementString);
+      logger2(`  - applied change: ${importPath} \u2192 ${finalPath}`);
+    } else {
+      logger2(`  - no change needed`);
     }
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
+    logger2(`\u2713 processed: ${filePath}`);
+  } else {
+    logger2(`  - no changes made to file`);
   }
   return changes;
 }
@@ -527,6 +566,7 @@ async function processAllFiles({
             results.push({ file: fullPath, changes });
           }
         } else {
+          logger2(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -550,6 +590,7 @@ async function convertImportsAliasToRelative({
   logger(
     `   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`
   );
+  logger2(`   (Using extension mode: ${pathExtFilter})`);
   const results = await processAllFiles({
     srcDir: targetDir,
     aliasToReplace: normalizedAlias,
@@ -558,12 +599,12 @@ async function convertImportsAliasToRelative({
     pathExtFilter
   });
   if (results.length > 0) {
-    logger("\n[convertImportsAliasToRelative] Summary of changes:", true);
+    logger("\n[convertImportsAliasToRelative] Summary of changes:");
     for (const { file, changes } of results) {
       const displayPath = relative(targetDir, file) || basename(file);
-      logger(() => `  in ${displayPath}:`, true);
+      logger(() => `  in ${displayPath}:`);
       for (const { from, to } of changes) {
-        logger(() => `    - ${from} \u2192 ${to}`, true);
+        logger(() => `    - ${from} \u2192 ${to}`);
       }
     }
   } else {
@@ -577,6 +618,9 @@ async function convertImportsExt({
   extTo,
   alias
 }) {
+  logger2(
+    `Converting import extensions from '${extFrom}' to '${extTo}' in "${targetDir}"...`
+  );
   const fromExtStr = extFrom === "none" ? "" : `.${extFrom}`;
   const toExtStr = extTo === "none" ? "" : `.${extTo}`;
   const normalizedAlias = alias ? alias.endsWith("/*") ? alias : `${alias}/*` : void 0;
@@ -649,24 +693,27 @@ async function convertImportsExt({
           }
           if (content !== updated) {
             await fs.writeFile(fullPath, updated);
+            logger2(`\u2713 processed: ${fullPath}`);
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           }
         } else {
+          logger2(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
     if (results.length > 0) {
-      logger("\n[convertImportsExt] Summary of changes:", true);
+      logger("\n[convertImportsExt] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        logger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          logger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     }
+    logger2("Extension conversion complete.");
     return results;
   } catch (error) {
     logger(
@@ -678,8 +725,12 @@ async function convertImportsExt({
 function stripPathSegments(path2, count = 1, alias = "") {
   if (typeof path2 !== "string" || path2.length === 0) return path2;
   if (count <= 0) return path2;
+  logger2(`[stripPathSegments] Processing path: ${path2}`);
+  logger2(`  - count: ${count}, alias: ${alias}`);
   const normalizedPath = normalizeWindowsPath(path2);
+  logger2(`  - normalized: ${normalizedPath}`);
   const parsed = parse(normalizedPath);
+  logger2(`  - parsed: ${JSON.stringify(parsed)}`);
   let pathSegments = [];
   if (parsed.dir && parsed.dir !== parsed.root) {
     let dirRelativeToRoot = parsed.dir;
@@ -692,26 +743,36 @@ function stripPathSegments(path2, count = 1, alias = "") {
     pathSegments.push(parsed.base);
   }
   pathSegments = pathSegments.filter(Boolean);
+  logger2(`  - initial segments: ${JSON.stringify(pathSegments)}`);
   const leadingPreservedSegments = [];
   if (alias && pathSegments.length > 0 && pathSegments[0]?.startsWith(alias)) {
     const preserved = pathSegments.shift();
     if (preserved) {
       leadingPreservedSegments.push(preserved);
+      logger2(`  - preserved alias segment: ${preserved}`);
     }
   }
   while (pathSegments.length > 0 && (pathSegments[0] === DOT || pathSegments[0] === DOUBLE_DOT)) {
     const preserved = pathSegments.shift();
     if (preserved) {
       leadingPreservedSegments.push(preserved);
+      logger2(`  - preserved relative segment: ${preserved}`);
     }
   }
   const numToStrip = Math.min(count, pathSegments.length);
   const remainingBodySegments = pathSegments.slice(numToStrip);
+  logger2(
+    `  - stripping ${numToStrip} segments from: ${JSON.stringify(pathSegments)}`
+  );
+  logger2(
+    `  - remaining body segments: ${JSON.stringify(remainingBodySegments)}`
+  );
   const pathRoot = parsed.root;
   const effectiveSegments = [
     ...leadingPreservedSegments,
     ...remainingBodySegments
   ];
+  logger2(`  - effective segments: ${JSON.stringify(effectiveSegments)}`);
   let result;
   if (effectiveSegments.length === 0) {
     result = normalize(pathRoot || DOT);
@@ -720,6 +781,7 @@ function stripPathSegments(path2, count = 1, alias = "") {
   } else {
     result = join(...effectiveSegments);
   }
+  logger2(`  - final result: ${result}`);
   return result;
 }
 async function stripPathSegmentsInDirectory({
@@ -729,13 +791,10 @@ async function stripPathSegmentsInDirectory({
   extensionsToProcess = EXTENSIONS
 }) {
   logger(
-    () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`,
-    true
-  );
-  logger(
-    () => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`,
-    true
+    () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`
   );
+  logger(() => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`);
+  logger2(`  - extensions: ${JSON.stringify(extensionsToProcess)}`);
   try {
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
     const results = [];
@@ -744,6 +803,7 @@ async function stripPathSegmentsInDirectory({
         const fullPath = join(targetDir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "node_modules") return;
+          logger2(`  - recursing into directory: ${entry.name}`);
           const subdirResults = await stripPathSegmentsInDirectory({
             targetDir: fullPath,
             segmentsToStrip,
@@ -752,54 +812,65 @@ async function stripPathSegmentsInDirectory({
           });
           results.push(...subdirResults);
         } else if (extensionsToProcess.includes(extname(entry.name))) {
+          logger2(`  Processing file: ${entry.name}`);
           const content = await fs.readFile(fullPath, "utf-8");
           let updated = content;
           const changes = [];
           const matches = Array.from(content.matchAll(IMPORT_REGEX));
+          logger2(`  - found ${matches.length} import statements`);
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
             if (!importPath) continue;
             if (!importPath.includes(SLASH)) {
+              logger2(`  - skipping non-path import: ${importPath}`);
               continue;
             }
             if (alias && !importPath.startsWith(alias.replace("/*", ""))) {
+              logger2(`  - skipping non-alias import: ${importPath}`);
               continue;
             }
+            logger2(`  Processing import: ${importPath}`);
             const strippedPath = stripPathSegments(
               importPath,
               segmentsToStrip,
               alias
             );
             if (importPath === strippedPath) {
+              logger2("  - no changes needed");
               continue;
             }
             changes.push({ from: importPath, to: strippedPath });
+            logger2(`  - transformed: ${importPath} \u2192 ${strippedPath}`);
             const searchStr = `${originalQuote}${importPath}${originalQuote}`;
             const replaceStr = `${originalQuote}${strippedPath}${originalQuote}`;
             updated = replaceAllInString(updated, searchStr, replaceStr);
           }
           if (content !== updated) {
             await fs.writeFile(fullPath, updated);
+            logger2("  \u2713 wrote changes to file");
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           } else {
+            logger2("  - no changes made to file");
           }
         } else {
+          logger2(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
     if (results.length > 0) {
-      logger(() => "[stripPathSegmentsInDirectory] Summary of changes:", true);
+      logger(() => "[stripPathSegmentsInDirectory] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        logger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          logger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     } else {
+      logger2("  No changes were made in any files");
     }
     return results;
   } catch (error) {
@@ -889,24 +960,23 @@ async function attachPathSegmentsInDirectory({
           }
           if (content !== updated) {
             await fs.writeFile(fullPath, updated);
+            logger2(`\u2713 processed: ${fullPath}`);
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           }
         } else {
+          logger2(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
     if (results.length > 0) {
-      logger(
-        () => "\n[attachPathSegmentsInDirectory] Summary of changes:",
-        true
-      );
+      logger(() => "\n[attachPathSegmentsInDirectory] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        logger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          logger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     }

package/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "name": "@reliverse/pathkit",
   "type": "module",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"