@reliverse/pathkit 1.1.3 → 1.1.5

package/README.md

@@ -12,7 +12,7 @@
 - ⚙️ **node.js api compatible** – familiar methods, no learning curve
 - 🚀 **modern & fast** – typescript, pure esm, bun & node‑ready
 - 🧠 **predictable & testable** – deterministic output across windows / macos / linux
-- 🧼 **no dependencies** – just better path api + couple of cool utilities = [5kB](https://bundlephobia.com/package/@reliverse/pathkit@latest)
+- 🧼 **no dependencies** – just better path api + couple of cool utilities = [4kB](https://bundlephobia.com/package/@reliverse/pathkit@latest)
 
 ## Installation
 

package/bin/mod.d.ts

@@ -19,14 +19,6 @@ export interface FormatInputPathObject {
 }
 type PathExtFilter = "js" | "ts" | "none" | "js-ts-none";
 type ImportExtType = "js" | "ts" | "none";
-/**
- * removes directories with recursive force option
- */
-declare function cleanDirs(dirs: string[]): Promise<void>;
-/**
- * recursively copies a directory and its contents
- */
-declare function copyDir(src: string, dest: string): Promise<void>;
 /**
  * normalizes windows paths to use forward slashes
  */
@@ -228,5 +220,5 @@ declare const path: PlatformPath & {
 declare const win32: PlatformPath;
 declare const delimiter: string;
 export type { PlatformPath, PathExtFilter, ImportExtType };
-export { _pathBase as posix, win32, basename, delimiter, dirname, extname, filename, format, isAbsolute, join, normalize, parse, relative, resolve, sep, toNamespacedPath, normalizeAliases, resolveAlias, reverseResolveAlias, normalizeWindowsPath, cleanDirs, copyDir, convertStringAliasRelative, convertImportsAliasToRelative, convertImportsExt, stripPathSegments, stripPathSegmentsInDirectory, attachPathSegments, attachPathSegmentsInDirectory, };
+export { _pathBase as posix, win32, basename, delimiter, dirname, extname, filename, format, isAbsolute, join, normalize, parse, relative, resolve, sep, toNamespacedPath, normalizeAliases, resolveAlias, reverseResolveAlias, normalizeWindowsPath, convertStringAliasRelative, convertImportsAliasToRelative, convertImportsExt, stripPathSegments, stripPathSegmentsInDirectory, attachPathSegments, attachPathSegmentsInDirectory, };
 export default path;

package/bin/mod.js

@@ -15,42 +15,6 @@ const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 const ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
 const IMPORT_REGEX = /(?:import\s+(?:[\s\S]*?)\s+from\s+|import\s*\(\s*)\s*(['"])([^'"]+)\1/g;
-async function cleanDirs(dirs) {
-  await Promise.all(
-    dirs.map(async (d) => {
-      try {
-        await fs.rm(d, { recursive: true, force: true });
-        logInternal(`\u2713 cleaned: ${d}`);
-      } catch (error) {
-        log(
-          `\u2717 error cleaning ${d}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    })
-  );
-}
-async function copyDir(src, dest) {
-  logInternal(`\u2713 copying: ${src} \u2192 ${dest}`);
-  try {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src, { withFileTypes: true });
-    await Promise.all(
-      entries.map(async (entry) => {
-        const srcPath = join(src, entry.name);
-        const destPath = join(dest, entry.name);
-        if (entry.isDirectory()) {
-          return copyDir(srcPath, destPath);
-        }
-        await fs.copyFile(srcPath, destPath);
-        logInternal(`  copied: ${srcPath} \u2192 ${destPath}`);
-      })
-    );
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    log(`\u2717 error copying directory ${src} to ${dest}: ${errorMsg}`);
-    throw error;
-  }
-}
 function normalizeWindowsPath(input = "") {
   if (!input) return input;
   return input.replace(/\\/g, SLASH).replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
@@ -438,13 +402,9 @@ async function resolveFileWithExtensions(basePath, extensions = ["", ...EXTENSIO
   return null;
 }
 function getTargetExtension(relPath, originalExt) {
-  const foundExt = extname(relPath);
   if (originalExt) {
     return relPath;
   }
-  if (foundExt) {
-    return relPath.slice(0, -foundExt.length);
-  }
   return relPath;
 }
 async function convertStringAliasRelative({
@@ -504,16 +464,16 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
       pathPattern: normalizedAlias,
       targetDir
     });
-    if (importPath !== relPath) {
-      changes.push({ from: importPath, 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}${relPath}${originalQuote}`;
+      const replacementString = `${originalQuote}${finalPath}${originalQuote}`;
       updated = replaceAllInString(updated, searchString, replacementString);
     }
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
-    logInternal(`\u2713 processed: ${filePath}`);
   }
   return changes;
 }
@@ -551,7 +511,6 @@ async function processAllFiles({
             results.push({ file: fullPath, changes });
           }
         } else {
-          logInternal(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -574,7 +533,6 @@ async function convertImportsAliasToRelative({
     `Converting aliased imports starting with '${aliasToReplace}' to relative paths in "${targetDir}"...`
   );
   log(`   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`);
-  logInternal(`   (Using extension mode: ${pathExtFilter})`);
   const results = await processAllFiles({
     srcDir: targetDir,
     aliasToReplace: normalizedAlias,
@@ -601,9 +559,6 @@ async function convertImportsExt({
   extFrom,
   extTo
 }) {
-  logInternal(
-    `Converting import extensions from '${extFrom}' to '${extTo}' in "${targetDir}"...`
-  );
   const fromExtStr = extFrom === "none" ? "" : `.${extFrom}`;
   const toExtStr = extTo === "none" ? "" : `.${extTo}`;
   const importRegex = new RegExp(
@@ -648,13 +603,11 @@ async function convertImportsExt({
           }
           if (content !== updated) {
             await fs.writeFile(fullPath, updated);
-            logInternal(`\u2713 processed: ${fullPath}`);
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           }
         } else {
-          logInternal(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -669,7 +622,6 @@ async function convertImportsExt({
       }
     } else {
     }
-    logInternal("Extension conversion complete.");
     return results;
   } catch (error) {
     log(
@@ -681,12 +633,8 @@ async function convertImportsExt({
 function stripPathSegments(path2, count = 1, alias = "") {
   if (typeof path2 !== "string" || path2.length === 0) return path2;
   if (count <= 0) return path2;
-  logInternal(`[stripPathSegments] Processing path: ${path2}`);
-  logInternal(`  - count: ${count}, alias: ${alias}`);
   const normalizedPath = normalizeWindowsPath(path2);
-  logInternal(`  - normalized: ${normalizedPath}`);
   const parsed = parse(normalizedPath);
-  logInternal(`  - parsed: ${JSON.stringify(parsed)}`);
   let pathSegments = [];
   if (parsed.dir && parsed.dir !== parsed.root) {
     let dirRelativeToRoot = parsed.dir;
@@ -699,32 +647,22 @@ function stripPathSegments(path2, count = 1, alias = "") {
     pathSegments.push(parsed.base);
   }
   pathSegments = pathSegments.filter(Boolean);
-  logInternal(`  - initial segments: ${JSON.stringify(pathSegments)}`);
   const leadingPreservedSegments = [];
   if (alias && pathSegments.length > 0 && pathSegments[0].startsWith(alias)) {
     const preserved = pathSegments.shift();
     leadingPreservedSegments.push(preserved);
-    logInternal(`  - preserved alias segment: ${preserved}`);
   }
   while (pathSegments.length > 0 && (pathSegments[0] === DOT || pathSegments[0] === DOUBLE_DOT)) {
     const preserved = pathSegments.shift();
     leadingPreservedSegments.push(preserved);
-    logInternal(`  - preserved relative segment: ${preserved}`);
   }
   const numToStrip = Math.min(count, pathSegments.length);
   const remainingBodySegments = pathSegments.slice(numToStrip);
-  logInternal(
-    `  - stripping ${numToStrip} segments from: ${JSON.stringify(pathSegments)}`
-  );
-  logInternal(
-    `  - remaining body segments: ${JSON.stringify(remainingBodySegments)}`
-  );
   const pathRoot = parsed.root;
   const effectiveSegments = [
     ...leadingPreservedSegments,
     ...remainingBodySegments
   ];
-  logInternal(`  - effective segments: ${JSON.stringify(effectiveSegments)}`);
   let result;
   if (effectiveSegments.length === 0) {
     result = normalize(pathRoot || DOT);
@@ -733,7 +671,6 @@ function stripPathSegments(path2, count = 1, alias = "") {
   } else {
     result = join(...effectiveSegments);
   }
-  logInternal(`  - final result: ${result}`);
   return result;
 }
 async function stripPathSegmentsInDirectory({
@@ -744,7 +681,6 @@ async function stripPathSegmentsInDirectory({
 }) {
   log(`[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`);
   log(`  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`);
-  logInternal(`  - extensions: ${JSON.stringify(extensionsToProcess)}`);
   try {
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
     const results = [];
@@ -753,7 +689,6 @@ async function stripPathSegmentsInDirectory({
         const fullPath = join(targetDir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "node_modules") return;
-          logInternal(`  - recursing into directory: ${entry.name}`);
           const subdirResults = await stripPathSegmentsInDirectory({
             targetDir: fullPath,
             segmentsToStrip,
@@ -762,50 +697,40 @@ async function stripPathSegmentsInDirectory({
           });
           results.push(...subdirResults);
         } else if (extensionsToProcess.includes(extname(entry.name))) {
-          logInternal(`  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));
-          logInternal(`  - found ${matches.length} import statements`);
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
             if (!importPath.includes(SLASH)) {
-              logInternal(`  - skipping non-path import: ${importPath}`);
               continue;
             }
             if (alias && !importPath.startsWith(alias.replace("/*", ""))) {
-              logInternal(`  - skipping non-alias import: ${importPath}`);
               continue;
             }
-            logInternal(`  Processing import: ${importPath}`);
             const strippedPath = stripPathSegments(
               importPath,
               segmentsToStrip,
               alias
             );
             if (importPath === strippedPath) {
-              logInternal("  - no changes needed");
               continue;
             }
             changes.push({ from: importPath, to: strippedPath });
-            logInternal(`  - 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);
-            logInternal("  \u2713 wrote changes to file");
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           } else {
-            logInternal("  - no changes made to file");
           }
         } else {
-          logInternal(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -819,7 +744,6 @@ async function stripPathSegmentsInDirectory({
         }
       }
     } else {
-      logInternal("  No changes were made in any files");
     }
     return results;
   } catch (error) {
@@ -908,13 +832,11 @@ async function attachPathSegmentsInDirectory({
           }
           if (content !== updated) {
             await fs.writeFile(fullPath, updated);
-            logInternal(`\u2713 processed: ${fullPath}`);
             if (changes.length > 0) {
               results.push({ file: fullPath, changes });
             }
           }
         } else {
-          logInternal(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -1016,8 +938,6 @@ export {
   resolveAlias,
   reverseResolveAlias,
   normalizeWindowsPath,
-  cleanDirs,
-  copyDir,
   convertStringAliasRelative,
   convertImportsAliasToRelative,
   convertImportsExt,

package/package.json

@@ -5,21 +5,21 @@
   "license": "MIT",
   "name": "@reliverse/pathkit",
   "type": "module",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@eslint/js": "^9.27.0",
-    "@reliverse/dler": "^1.3.6",
+    "@reliverse/dler": "^1.4.6",
     "@reliverse/relifso": "^1.2.10",
-    "@reliverse/relinka": "^1.4.5",
+    "@reliverse/relinka": "^1.4.6",
     "@reliverse/rematch": "^1.1.0",
     "@stylistic/eslint-plugin": "^4.2.0",
-    "@types/bun": "^1.2.13",
+    "@types/bun": "^1.2.14",
     "@types/node": "^22.15.21",
     "eslint": "^9.27.0",
     "eslint-plugin-no-relative-import-paths": "^1.6.1",
     "eslint-plugin-perfectionist": "^4.13.0",
-    "knip": "^5.57.1",
+    "knip": "^5.57.2",
     "magic-string": "^0.30.17",
     "p-map": "^7.0.3",
     "typescript": "^5.8.3",
@@ -39,4 +39,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}