@reliverse/pathkit 1.2.5 → 1.2.7

package/bin/mod.d.ts

@@ -97,10 +97,11 @@ declare function convertStringAliasRelative({ importPath, importerFile, pathPatt
 /**
  * main function to convert import paths from aliases to relative paths
  */
-declare function convertImportsAliasToRelative({ targetDir, aliasToReplace, pathExtFilter, }: {
+declare function convertImportsAliasToRelative({ targetDir, aliasToReplace, pathExtFilter, displayLogsOnlyFor, }: {
     targetDir: string;
     aliasToReplace: string;
     pathExtFilter: PathExtFilter;
+    displayLogsOnlyFor?: string[];
 }): Promise<{
     file: string;
     changes: {

package/bin/mod.js

@@ -2,19 +2,21 @@ 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 regularLogger = (msg) => {
+  const message = typeof msg === "function" ? msg() : msg;
+  console.log(`\x1B[2m${message}\x1B[0m`);
+};
+const filteredLogger = (msg) => {
+  const message = typeof msg === "function" ? msg() : msg;
+  console.log(`\x1B[36;2m${message}\x1B[0m`);
 };
 const logInternal = (msg) => {
+  const DEBUG_MODE = true;
   if (DEBUG_MODE) {
     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 = "\\";
@@ -462,43 +464,62 @@ function replaceAllInString(original, searchValue, replaceValue) {
   }
   return result;
 }
-async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
+async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter, displayLogsOnlyFor) {
+  const shouldLog = !displayLogsOnlyFor || displayLogsOnlyFor.includes(filePath);
+  const log = (msg) => shouldLog && filteredLogger(msg);
   const content = await fs.readFile(filePath, "utf-8");
   let updated = content;
   const changes = [];
   const matches = Array.from(content.matchAll(IMPORT_REGEX));
   const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
   const baseAlias = aliasToReplace.replace("/*", "");
+  log(`[processFile] Processing file: ${filePath}`);
+  log(`  - normalizedAlias: ${normalizedAlias}`);
+  log(`  - baseAlias: ${baseAlias}`);
+  log(`  - found ${matches.length} import statements`);
   for (const match of matches) {
     const originalQuote = match[1];
     const importPath = match[2];
     if (!importPath) continue;
+    log(`  Processing import: ${importPath}`);
     if (!importPath.startsWith(baseAlias)) {
+      log(`  - 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";
+    const shouldProcess = pathExtFilter === "js" && importExt === ".js" || // process paths with .js extension
+    pathExtFilter === "ts" && importExt === ".ts" || // process paths with .ts extension
+    pathExtFilter === "none" && importExt === "" || // process paths without any extension
+    pathExtFilter === "js-ts-none";
     if (!shouldProcess) {
+      log(`  - skipping: doesn't match pathExtFilter ${pathExtFilter}`);
       continue;
     }
+    log(`  - converting alias to relative path...`);
     const relPath = await convertStringAliasRelative({
       importPath,
       importerFile: filePath,
       pathPattern: normalizedAlias,
       targetDir
     });
+    log(`  - original path: ${importPath}`);
+    log(`  - 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);
+      log(`  - applied change: ${importPath} \u2192 ${finalPath}`);
     } else {
+      log(`  - no change needed`);
     }
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
+    log(`\u2713 processed: ${filePath}`);
   } else {
+    log(`  - no changes made to file`);
   }
   return changes;
 }
@@ -507,7 +528,8 @@ async function processAllFiles({
   aliasToReplace,
   extensionsToProcess,
   rootDir,
-  pathExtFilter
+  pathExtFilter,
+  displayLogsOnlyFor
 }) {
   try {
     const entries = await fs.readdir(srcDir, { withFileTypes: true });
@@ -522,7 +544,8 @@ async function processAllFiles({
             aliasToReplace,
             extensionsToProcess,
             rootDir,
-            pathExtFilter
+            pathExtFilter,
+            displayLogsOnlyFor
           });
           results.push(...subdirResults);
         } else if (extensionsToProcess.includes(extname(entry.name))) {
@@ -530,7 +553,8 @@ async function processAllFiles({
             fullPath,
             aliasToReplace,
             rootDir,
-            pathExtFilter
+            pathExtFilter,
+            displayLogsOnlyFor
           );
           if (changes.length > 0) {
             results.push({ file: fullPath, changes });
@@ -541,7 +565,7 @@ async function processAllFiles({
     );
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${srcDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -550,13 +574,14 @@ async function processAllFiles({
 async function convertImportsAliasToRelative({
   targetDir,
   aliasToReplace,
-  pathExtFilter
+  pathExtFilter,
+  displayLogsOnlyFor
 }) {
   const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
-  logger(
+  regularLogger(
     `Converting aliased imports starting with '${aliasToReplace}' to relative paths in "${targetDir}"...`
   );
-  logger(
+  regularLogger(
     `   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`
   );
   const results = await processAllFiles({
@@ -564,20 +589,20 @@ async function convertImportsAliasToRelative({
     aliasToReplace: normalizedAlias,
     extensionsToProcess: EXTENSIONS,
     rootDir: targetDir,
-    pathExtFilter
+    pathExtFilter,
+    displayLogsOnlyFor
   });
   if (results.length > 0) {
-    logger("\n[convertImportsAliasToRelative] Summary of changes:", true);
+    regularLogger("\n[convertImportsAliasToRelative] Summary of changes:");
     for (const { file, changes } of results) {
       const displayPath = relative(targetDir, file) || basename(file);
-      logger(() => `  in ${displayPath}:`, true);
+      regularLogger(() => `  in ${displayPath}:`);
       for (const { from, to } of changes) {
-        logger(() => `    - ${from} \u2192 ${to}`, true);
+        regularLogger(() => `    - ${from} \u2192 ${to}`);
       }
     }
-  } else {
   }
-  logger("Import path conversion process complete.");
+  regularLogger("Import path conversion process complete.");
   return results;
 }
 async function convertImportsExt({
@@ -667,18 +692,18 @@ async function convertImportsExt({
       })
     );
     if (results.length > 0) {
-      logger("\n[convertImportsExt] Summary of changes:", true);
+      regularLogger("\n[convertImportsExt] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          regularLogger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     }
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -737,13 +762,11 @@ async function stripPathSegmentsInDirectory({
   alias = "",
   extensionsToProcess = EXTENSIONS
 }) {
-  logger(
-    () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`,
-    true
+  regularLogger(
+    () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`
   );
-  logger(
-    () => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`,
-    true
+  regularLogger(
+    () => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`
   );
   try {
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
@@ -800,19 +823,19 @@ async function stripPathSegmentsInDirectory({
       })
     );
     if (results.length > 0) {
-      logger(() => "[stripPathSegmentsInDirectory] Summary of changes:", true);
+      regularLogger(() => "[stripPathSegmentsInDirectory] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          regularLogger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     } else {
     }
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -907,21 +930,20 @@ async function attachPathSegmentsInDirectory({
       })
     );
     if (results.length > 0) {
-      logger(
-        () => "\n[attachPathSegmentsInDirectory] Summary of changes:",
-        true
+      regularLogger(
+        () => "\n[attachPathSegmentsInDirectory] Summary of changes:"
       );
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`, true);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`, true);
+          regularLogger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     }
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];

package/package.json

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