@reliverse/pathkit 1.1.4 → 1.1.6

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/impl/getFileImportsExports.d.ts

@@ -0,0 +1,27 @@
+export interface ImportExportSpecifier {
+    type: "named" | "default" | "namespace" | "all";
+    name: string;
+    alias?: string;
+    isType?: boolean;
+}
+export interface ImportExportInfo {
+    statement: string;
+    type: "static" | "dynamic";
+    kind: "import" | "export";
+    source?: string;
+    pathType?: "alias" | "relative" | "absolute" | "bare" | "module";
+    pathTypeSymbol?: string;
+    isTypeOnly?: boolean;
+    specifiers?: ImportExportSpecifier[];
+    start: number;
+    end: number;
+}
+export interface GetFileImportsExportsOptions {
+    kind?: "import" | "export" | "all";
+    pathTypes?: ("alias" | "relative" | "absolute" | "bare" | "module")[];
+    limitPerType?: number;
+}
+/**
+ * analyzes a file's content to extract import and export statements
+ */
+export declare function getFileImportsExports(content: string, options?: GetFileImportsExportsOptions): ImportExportInfo[];

package/bin/impl/getFileImportsExports.js

@@ -0,0 +1,189 @@
+export function getFileImportsExports(content, options = {}) {
+  const {
+    kind = "all",
+    pathTypes = ["alias", "relative", "absolute", "bare", "module"],
+    limitPerType
+  } = options;
+  const results = [];
+  const patterns = {
+    // import statements with from clause
+    staticImport: /import\s+(?:type\s+)?(?:(?:\w+)(?:\s*,\s*)?)?(?:\{[^}]*\}|\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]|import\s+(?:type\s+)?(\w+)\s+from\s+['"]([^'"]+)['"]/g,
+    // dynamic imports
+    dynamicImport: /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    // export statements with from clause
+    staticExport: /export\s+(?:type\s+)?(?:\{[^}]*\}|\*(?:\s+as\s+\w+)?)\s+from\s+['"]([^'"]+)['"]/g,
+    // default exports without from
+    defaultExport: /export\s+default\s+(?:\w+|\{[^}]*\}|class\s+\w+|function\s+\w+)/g,
+    // named exports without from
+    namedExport: /export\s+(?:const|let|var|function|class|enum|interface|type)\s+(\w+)/g
+  };
+  function getPathType(path) {
+    if (path.startsWith(".")) return "relative";
+    if (path.startsWith("/")) return "absolute";
+    if (path.startsWith("@") || path.startsWith("~")) return "alias";
+    if (path.startsWith("http://") || path.startsWith("https://"))
+      return "module";
+    return "bare";
+  }
+  function extractSpecifiers(statement) {
+    const specifiers = [];
+    const isTypeOnly = statement.includes("import type") || statement.includes("export type");
+    const namespaceMatch = /(?:import|export)\s+(?:type\s+)?\*\s+as\s+(\w+)/.exec(statement);
+    if (namespaceMatch) {
+      specifiers.push({
+        type: "namespace",
+        name: namespaceMatch[1],
+        isType: isTypeOnly
+      });
+      return specifiers;
+    }
+    const defaultMatch = /import\s+(?:type\s+)?(\w+)(?:\s*,|\s+from)/.exec(
+      statement
+    );
+    if (defaultMatch && !statement.includes("{")) {
+      specifiers.push({
+        type: "default",
+        name: defaultMatch[1],
+        isType: isTypeOnly
+      });
+    }
+    const namedMatch = /{([^}]*)}/.exec(statement);
+    if (namedMatch) {
+      const items = namedMatch[1].split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+      for (const item of items) {
+        const typeMatch = /^type\s+(.+)/.exec(item);
+        const actualItem = typeMatch ? typeMatch[1] : item;
+        const isItemType = !!typeMatch || isTypeOnly;
+        if (actualItem.includes(" as ")) {
+          const [name, alias] = actualItem.split(" as ").map((p) => p.trim());
+          specifiers.push({
+            type: "named",
+            name,
+            alias,
+            isType: isItemType
+          });
+        } else {
+          specifiers.push({
+            type: "named",
+            name: actualItem,
+            isType: isItemType
+          });
+        }
+      }
+    }
+    return specifiers;
+  }
+  if (kind === "import" || kind === "all") {
+    const importMatches = [...content.matchAll(patterns.staticImport)];
+    for (const match of importMatches) {
+      const source = match[1] || match[3];
+      if (!source) continue;
+      const pathType = getPathType(source);
+      if (!pathTypes.includes(pathType)) continue;
+      const info = {
+        statement: match[0],
+        type: "static",
+        kind: "import",
+        source,
+        pathType,
+        pathTypeSymbol: pathType === "alias" ? /^[@~]/.exec(source)?.[0] : void 0,
+        isTypeOnly: match[0].includes("import type"),
+        specifiers: extractSpecifiers(match[0]),
+        start: match.index,
+        end: match.index + match[0].length
+      };
+      results.push(info);
+    }
+    const dynamicMatches = [...content.matchAll(patterns.dynamicImport)];
+    for (const match of dynamicMatches) {
+      const source = match[1];
+      if (!source) continue;
+      const pathType = getPathType(source);
+      if (!pathTypes.includes(pathType)) continue;
+      const info = {
+        statement: match[0],
+        type: "dynamic",
+        kind: "import",
+        source,
+        pathType,
+        pathTypeSymbol: pathType === "alias" ? /^[@~]/.exec(source)?.[0] : void 0,
+        isTypeOnly: false,
+        specifiers: [],
+        start: match.index,
+        end: match.index + match[0].length
+      };
+      results.push(info);
+    }
+  }
+  if (kind === "export" || kind === "all") {
+    const exportMatches = [...content.matchAll(patterns.staticExport)];
+    for (const match of exportMatches) {
+      const source = match[1];
+      if (!source) continue;
+      const pathType = getPathType(source);
+      if (!pathTypes.includes(pathType)) continue;
+      const info = {
+        statement: match[0],
+        type: "static",
+        kind: "export",
+        source,
+        pathType,
+        pathTypeSymbol: pathType === "alias" ? /^[@~]/.exec(source)?.[0] : void 0,
+        isTypeOnly: match[0].includes("export type"),
+        specifiers: extractSpecifiers(match[0]),
+        start: match.index,
+        end: match.index + match[0].length
+      };
+      results.push(info);
+    }
+    const defaultMatches = [...content.matchAll(patterns.defaultExport)];
+    for (const match of defaultMatches) {
+      const info = {
+        statement: match[0],
+        type: "static",
+        kind: "export",
+        source: void 0,
+        pathType: void 0,
+        pathTypeSymbol: void 0,
+        isTypeOnly: false,
+        specifiers: [{ type: "default", name: "default" }],
+        start: match.index,
+        end: match.index + match[0].length
+      };
+      results.push(info);
+    }
+    const namedMatches = [...content.matchAll(patterns.namedExport)];
+    for (const match of namedMatches) {
+      const name = match[1];
+      if (!name) continue;
+      const info = {
+        statement: match[0],
+        type: "static",
+        kind: "export",
+        source: void 0,
+        pathType: void 0,
+        pathTypeSymbol: void 0,
+        isTypeOnly: match[0].includes("export type"),
+        specifiers: [{ type: "named", name }],
+        start: match.index,
+        end: match.index + match[0].length
+      };
+      results.push(info);
+    }
+  }
+  if (limitPerType) {
+    const groupedByType = results.reduce(
+      (acc, curr) => {
+        const key = `${curr.kind}-${curr.pathType || "none"}`;
+        if (!acc[key]) acc[key] = [];
+        acc[key].push(curr);
+        return acc;
+      },
+      {}
+    );
+    return Object.values(groupedByType).flatMap(
+      (group) => group.slice(0, limitPerType)
+    );
+  }
+  return results;
+}

package/bin/mod.d.ts

@@ -1,4 +1,5 @@
 import type { PlatformPath } from "node:path";
+import { getFileImportsExports, type ImportExportInfo, type ImportExportSpecifier, type GetFileImportsExportsOptions } from "./impl/getFileImportsExports.js";
 declare const normalizedAliasSymbol: unique symbol;
 interface NormalizedRecord extends Record<string, string> {
     [normalizedAliasSymbol]?: true;
@@ -19,14 +20,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
  */
@@ -227,6 +220,6 @@ 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 type { PlatformPath, PathExtFilter, ImportExtType, ImportExportInfo, ImportExportSpecifier, GetFileImportsExportsOptions, };
+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, getFileImportsExports, };
 export default path;

package/bin/mod.js

@@ -1,4 +1,7 @@
 import fs from "node:fs/promises";
+import {
+  getFileImportsExports
+} from "./impl/getFileImportsExports.js";
 const log = (msg) => console.log(`\x1B[2m${msg}\x1B[0m`);
 const logInternal = (msg) => console.log(`\x1B[36;2m${msg}\x1B[0m`);
 const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
@@ -15,42 +18,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());
@@ -510,7 +477,6 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
-    logInternal(`\u2713 processed: ${filePath}`);
   }
   return changes;
 }
@@ -548,7 +514,6 @@ async function processAllFiles({
             results.push({ file: fullPath, changes });
           }
         } else {
-          logInternal(`  - skipping non-matching file: ${entry.name}`);
         }
       })
     );
@@ -571,7 +536,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,
@@ -598,9 +562,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(
@@ -625,8 +586,9 @@ async function convertImportsExt({
           const content = await fs.readFile(fullPath, "utf-8");
           let updated = content;
           const changes = [];
-          const matches = Array.from(content.matchAll(importRegex));
-          for (const match of matches) {
+          let match;
+          match = importRegex.exec(content);
+          while (match !== null) {
             const quote = match[1];
             const importPath = match[2];
             let replacementPath;
@@ -642,16 +604,15 @@ async function convertImportsExt({
             const searchStr = `${quote}${importPath}${quote}`;
             const replaceStr = `${quote}${replacementPath}${quote}`;
             updated = replaceAllInString(updated, searchStr, replaceStr);
+            match = importRegex.exec(updated);
           }
           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}`);
         }
       })
     );
@@ -666,7 +627,6 @@ async function convertImportsExt({
       }
     } else {
     }
-    logInternal("Extension conversion complete.");
     return results;
   } catch (error) {
     log(
@@ -678,12 +638,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;
@@ -696,32 +652,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);
@@ -730,7 +676,6 @@ function stripPathSegments(path2, count = 1, alias = "") {
   } else {
     result = join(...effectiveSegments);
   }
-  logInternal(`  - final result: ${result}`);
   return result;
 }
 async function stripPathSegmentsInDirectory({
@@ -741,7 +686,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 = [];
@@ -750,7 +694,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,
@@ -759,50 +702,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}`);
         }
       })
     );
@@ -816,7 +749,6 @@ async function stripPathSegmentsInDirectory({
         }
       }
     } else {
-      logInternal("  No changes were made in any files");
     }
     return results;
   } catch (error) {
@@ -905,13 +837,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}`);
         }
       })
     );
@@ -1013,14 +943,13 @@ export {
   resolveAlias,
   reverseResolveAlias,
   normalizeWindowsPath,
-  cleanDirs,
-  copyDir,
   convertStringAliasRelative,
   convertImportsAliasToRelative,
   convertImportsExt,
   stripPathSegments,
   stripPathSegmentsInDirectory,
   attachPathSegments,
-  attachPathSegmentsInDirectory
+  attachPathSegmentsInDirectory,
+  getFileImportsExports
 };
 export default path;

package/package.json

@@ -5,26 +5,8 @@
   "license": "MIT",
   "name": "@reliverse/pathkit",
   "type": "module",
-  "version": "1.1.4",
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@eslint/js": "^9.27.0",
-    "@reliverse/dler": "^1.3.6",
-    "@reliverse/relifso": "^1.2.10",
-    "@reliverse/relinka": "^1.4.5",
-    "@reliverse/rematch": "^1.1.0",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "@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.2",
-    "magic-string": "^0.30.17",
-    "p-map": "^7.0.3",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.32.1"
-  },
+  "version": "1.1.6",
+  "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"
   },
@@ -39,4 +21,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}