@reliverse/pathkit 1.2.6 → 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,14 +2,21 @@ import fs from "node:fs/promises";
 import {
   getFileImportsExports
 } from "./impl/getFileImportsExports.js";
-const logger = (msg) => {
+const regularLogger = (msg) => {
   const message = typeof msg === "function" ? msg() : msg;
   console.log(`\x1B[2m${message}\x1B[0m`);
 };
-const logger2 = (msg) => {
+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 EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts"];
 const SLASH = "/";
 const BACK_SLASH = "\\";
@@ -350,20 +357,15 @@ 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) {
-    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,
@@ -374,15 +376,11 @@ 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,
@@ -393,7 +391,6 @@ const findAliasMatch = (importPath, paths) => {
       }
     }
   }
-  logger2(`  - no match found`);
   return null;
 };
 const toRelativeImport = (absPath, fromDir) => {
@@ -435,32 +432,21 @@ 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) {
-    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);
   const result = getTargetExtension(relPath, originalExt);
-  logger2(`  - final result: ${result}`);
   return result;
 }
 function replaceAllInString(original, searchValue, replaceValue) {
@@ -478,57 +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("/*", "");
-  logger2(`[processFile] Processing file: ${filePath}`);
-  logger2(`  - normalizedAlias: ${normalizedAlias}`);
-  logger2(`  - baseAlias: ${baseAlias}`);
-  logger2(`  - found ${matches.length} import statements`);
+  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;
-    logger2(`  Processing import: ${importPath}`);
+    log(`  Processing import: ${importPath}`);
     if (!importPath.startsWith(baseAlias)) {
-      logger2(`  - skipping: import doesn't start with ${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) {
-      logger2(`  - skipping: doesn't match pathExtFilter ${pathExtFilter}`);
+      log(`  - skipping: doesn't match pathExtFilter ${pathExtFilter}`);
       continue;
     }
-    logger2(`  - converting alias to relative path...`);
+    log(`  - converting alias to relative path...`);
     const relPath = await convertStringAliasRelative({
       importPath,
       importerFile: filePath,
       pathPattern: normalizedAlias,
       targetDir
     });
-    logger2(`  - original path: ${importPath}`);
-    logger2(`  - converted to: ${relPath}`);
+    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);
-      logger2(`  - applied change: ${importPath} \u2192 ${finalPath}`);
+      log(`  - applied change: ${importPath} \u2192 ${finalPath}`);
     } else {
-      logger2(`  - no change needed`);
+      log(`  - no change needed`);
     }
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
-    logger2(`\u2713 processed: ${filePath}`);
+    log(`\u2713 processed: ${filePath}`);
   } else {
-    logger2(`  - no changes made to file`);
+    log(`  - no changes made to file`);
   }
   return changes;
 }
@@ -537,7 +528,8 @@ async function processAllFiles({
   aliasToReplace,
   extensionsToProcess,
   rootDir,
-  pathExtFilter
+  pathExtFilter,
+  displayLogsOnlyFor
 }) {
   try {
     const entries = await fs.readdir(srcDir, { withFileTypes: true });
@@ -552,7 +544,8 @@ async function processAllFiles({
             aliasToReplace,
             extensionsToProcess,
             rootDir,
-            pathExtFilter
+            pathExtFilter,
+            displayLogsOnlyFor
           });
           results.push(...subdirResults);
         } else if (extensionsToProcess.includes(extname(entry.name))) {
@@ -560,19 +553,19 @@ async function processAllFiles({
             fullPath,
             aliasToReplace,
             rootDir,
-            pathExtFilter
+            pathExtFilter,
+            displayLogsOnlyFor
           );
           if (changes.length > 0) {
             results.push({ file: fullPath, changes });
           }
         } else {
-          logger2(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${srcDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -581,35 +574,35 @@ 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}")`
   );
-  logger2(`   (Using extension mode: ${pathExtFilter})`);
   const results = await processAllFiles({
     srcDir: targetDir,
     aliasToReplace: normalizedAlias,
     extensionsToProcess: EXTENSIONS,
     rootDir: targetDir,
-    pathExtFilter
+    pathExtFilter,
+    displayLogsOnlyFor
   });
   if (results.length > 0) {
-    logger("\n[convertImportsAliasToRelative] Summary of changes:");
+    regularLogger("\n[convertImportsAliasToRelative] Summary of changes:");
     for (const { file, changes } of results) {
       const displayPath = relative(targetDir, file) || basename(file);
-      logger(() => `  in ${displayPath}:`);
+      regularLogger(() => `  in ${displayPath}:`);
       for (const { from, to } of changes) {
-        logger(() => `    - ${from} \u2192 ${to}`);
+        regularLogger(() => `    - ${from} \u2192 ${to}`);
       }
     }
-  } else {
   }
-  logger("Import path conversion process complete.");
+  regularLogger("Import path conversion process complete.");
   return results;
 }
 async function convertImportsExt({
@@ -618,9 +611,6 @@ 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;
@@ -693,30 +683,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:");
+      regularLogger("\n[convertImportsExt] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`);
+          regularLogger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     }
-    logger2("Extension conversion complete.");
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -725,12 +712,8 @@ 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;
@@ -743,36 +726,26 @@ 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);
@@ -781,7 +754,6 @@ function stripPathSegments(path2, count = 1, alias = "") {
   } else {
     result = join(...effectiveSegments);
   }
-  logger2(`  - final result: ${result}`);
   return result;
 }
 async function stripPathSegmentsInDirectory({
@@ -790,11 +762,12 @@ async function stripPathSegmentsInDirectory({
   alias = "",
   extensionsToProcess = EXTENSIONS
 }) {
-  logger(
+  regularLogger(
     () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`
   );
-  logger(() => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`);
-  logger2(`  - extensions: ${JSON.stringify(extensionsToProcess)}`);
+  regularLogger(
+    () => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`
+  );
   try {
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
     const results = [];
@@ -803,7 +776,6 @@ 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,
@@ -812,69 +784,58 @@ 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:");
+      regularLogger(() => "[stripPathSegmentsInDirectory] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`);
+          regularLogger(() => `    - ${from} \u2192 ${to}`);
         }
       }
     } else {
-      logger2("  No changes were made in any files");
     }
     return results;
   } catch (error) {
-    logger(
+    regularLogger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -960,29 +921,29 @@ 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:");
+      regularLogger(
+        () => "\n[attachPathSegmentsInDirectory] Summary of changes:"
+      );
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        logger(() => `  in ${displayPath}:`);
+        regularLogger(() => `  in ${displayPath}:`);
         for (const { from, to } of changes) {
-          logger(() => `    - ${from} \u2192 ${to}`);
+          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.6",
+  "version": "1.2.7",
   "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"