@reliverse/pathkit 1.1.5 → 1.1.7

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,191 @@
+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?.[1]) {
+      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?.[1] && !statement.includes("{")) {
+      specifiers.push({
+        type: "default",
+        name: defaultMatch[1],
+        isType: isTypeOnly
+      });
+    }
+    const namedMatch = /{([^}]*)}/.exec(statement);
+    if (namedMatch?.[1]) {
+      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;
+        if (!actualItem) continue;
+        const isItemType = !!typeMatch || isTypeOnly;
+        if (actualItem.includes(" as ")) {
+          const [name, alias] = actualItem.split(" as ").map((p) => p.trim());
+          if (!name) continue;
+          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 (!pathType || !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 ?? 0,
+        end: (match.index ?? 0) + 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 (!pathType || !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 ?? 0,
+        end: (match.index ?? 0) + 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 (!pathType || !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 ?? 0,
+        end: (match.index ?? 0) + 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;
@@ -18,7 +19,7 @@ export interface FormatInputPathObject {
     name?: string;
 }
 type PathExtFilter = "js" | "ts" | "none" | "js-ts-none";
-type ImportExtType = "js" | "ts" | "none";
+type ImportExtType = "js" | "ts" | "none" | "none-and-js";
 /**
  * normalizes windows paths to use forward slashes
  */
@@ -96,8 +97,7 @@ declare function convertStringAliasRelative({ importPath, importerFile, pathPatt
 /**
  * main function to convert import paths from aliases to relative paths
  */
-declare function convertImportsAliasToRelative({ targetDir, aliasToReplace, // e.g. @, ~, @/*, ~/*
-pathExtFilter, }: {
+declare function convertImportsAliasToRelative({ targetDir, aliasToReplace, pathExtFilter, }: {
     targetDir: string;
     aliasToReplace: string;
     pathExtFilter: PathExtFilter;
@@ -219,6 +219,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, 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,6 +1,20 @@
 import fs from "node:fs/promises";
-const log = (msg) => console.log(`\x1B[2m${msg}\x1B[0m`);
-const logInternal = (msg) => console.log(`\x1B[36;2m${msg}\x1B[0m`);
+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 logInternal = (msg) => {
+  if (DEBUG_MODE) {
+    const message = typeof msg === "function" ? msg() : msg;
+    console.log(`\x1B[36;2m${message}\x1B[0m`);
+  }
+};
+const DEBUG_MODE = false;
 const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 const SLASH = "/";
 const BACK_SLASH = "\\";
@@ -36,7 +50,7 @@ function normalizeString(path2, allowAboveRoot) {
   let char = null;
   for (let index = 0; index <= path2.length; ++index) {
     if (index < path2.length) {
-      char = path2[index];
+      char = path2[index] ?? null;
     } else if (char === SLASH) {
       break;
     } else {
@@ -187,7 +201,7 @@ const relative = (from, to) => {
   if (resolvedFrom === resolvedTo) return EMPTY;
   const fromSegments = resolvedFrom.replace(ROOT_FOLDER_RE, "$1").split(SLASH).filter(Boolean);
   const toSegments = resolvedTo.replace(ROOT_FOLDER_RE, "$1").split(SLASH).filter(Boolean);
-  if (fromSegments.length > 0 && toSegments.length > 0 && DRIVE_LETTER_RE.test(fromSegments[0]) && DRIVE_LETTER_RE.test(toSegments[0]) && fromSegments[0].toUpperCase() !== toSegments[0].toUpperCase()) {
+  if (fromSegments.length > 0 && toSegments.length > 0 && fromSegments[0] && toSegments[0] && DRIVE_LETTER_RE.test(fromSegments[0]) && DRIVE_LETTER_RE.test(toSegments[0]) && fromSegments[0].toUpperCase() !== toSegments[0].toUpperCase()) {
     return resolvedTo;
   }
   let commonSegments = 0;
@@ -342,6 +356,7 @@ function reverseResolveAlias(path2, aliases) {
 }
 const findAliasMatch = (importPath, paths) => {
   const firstPathKey = Object.keys(paths)[0];
+  if (!firstPathKey) return null;
   const baseAlias = firstPathKey.replace("/*", "");
   if (importPath.startsWith("@") && !importPath.startsWith(baseAlias)) {
     return null;
@@ -452,6 +467,7 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
   for (const match of matches) {
     const originalQuote = match[1];
     const importPath = match[2];
+    if (!importPath) continue;
     if (!importPath.startsWith(baseAlias)) {
       continue;
     }
@@ -516,7 +532,7 @@ async function processAllFiles({
     );
     return results;
   } catch (error) {
-    log(
+    logger(
       `error processing directory ${srcDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -525,14 +541,15 @@ async function processAllFiles({
 async function convertImportsAliasToRelative({
   targetDir,
   aliasToReplace,
-  // e.g. @, ~, @/*, ~/*
   pathExtFilter
 }) {
   const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
-  log(
+  logger(
     `Converting aliased imports starting with '${aliasToReplace}' to relative paths in "${targetDir}"...`
   );
-  log(`   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`);
+  logger(
+    `   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`
+  );
   const results = await processAllFiles({
     srcDir: targetDir,
     aliasToReplace: normalizedAlias,
@@ -541,17 +558,17 @@ async function convertImportsAliasToRelative({
     pathExtFilter
   });
   if (results.length > 0) {
-    log("\n[convertImportsAliasToRelative] Summary of changes:");
+    logger("\n[convertImportsAliasToRelative] Summary of changes:", true);
     for (const { file, changes } of results) {
       const displayPath = relative(targetDir, file) || basename(file);
-      log(`  in ${displayPath}:`);
+      logger(() => `  in ${displayPath}:`, true);
       for (const { from, to } of changes) {
-        log(`    - ${from} \u2192 ${to}`);
+        logger(() => `    - ${from} \u2192 ${to}`, true);
       }
     }
   } else {
   }
-  log("Import path conversion process complete.");
+  logger("Import path conversion process complete.");
   return results;
 }
 async function convertImportsExt({
@@ -559,7 +576,7 @@ async function convertImportsExt({
   extFrom,
   extTo
 }) {
-  const fromExtStr = extFrom === "none" ? "" : `.${extFrom}`;
+  const fromExtStr = extFrom === "none" ? "" : extFrom === "none-and-js" ? "(?:\\.js)?" : `.${extFrom}`;
   const toExtStr = extTo === "none" ? "" : `.${extTo}`;
   const importRegex = new RegExp(
     `(?:import\\s+(?:[\\s\\S]*?)\\s+from\\s+|import\\s*\\(\\s*)\\s*(['"])([^'"]+${fromExtStr.replace(".", "\\.")})(\\1)`,
@@ -583,13 +600,21 @@ 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];
+            if (!importPath) continue;
             let replacementPath;
             if (extFrom === "none") {
               replacementPath = importPath + toExtStr;
+            } else if (extFrom === "none-and-js") {
+              if (importPath.endsWith(".js")) {
+                replacementPath = importPath.slice(0, -3) + toExtStr;
+              } else {
+                replacementPath = importPath + toExtStr;
+              }
             } else if (extTo === "none") {
               replacementPath = importPath.slice(0, -fromExtStr.length);
             } else {
@@ -600,6 +625,7 @@ 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);
@@ -612,19 +638,18 @@ async function convertImportsExt({
       })
     );
     if (results.length > 0) {
-      log("\n[convertImportsExt] Summary of changes:");
+      logger("\n[convertImportsExt] Summary of changes:", true);
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        log(`  in ${displayPath}:`);
+        logger(() => `  in ${displayPath}:`, true);
         for (const { from, to } of changes) {
-          log(`    - ${from} \u2192 ${to}`);
+          logger(() => `    - ${from} \u2192 ${to}`, true);
         }
       }
-    } else {
     }
     return results;
   } catch (error) {
-    log(
+    logger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -648,13 +673,17 @@ function stripPathSegments(path2, count = 1, alias = "") {
   }
   pathSegments = pathSegments.filter(Boolean);
   const leadingPreservedSegments = [];
-  if (alias && pathSegments.length > 0 && pathSegments[0].startsWith(alias)) {
+  if (alias && pathSegments.length > 0 && pathSegments[0]?.startsWith(alias)) {
     const preserved = pathSegments.shift();
-    leadingPreservedSegments.push(preserved);
+    if (preserved) {
+      leadingPreservedSegments.push(preserved);
+    }
   }
   while (pathSegments.length > 0 && (pathSegments[0] === DOT || pathSegments[0] === DOUBLE_DOT)) {
     const preserved = pathSegments.shift();
-    leadingPreservedSegments.push(preserved);
+    if (preserved) {
+      leadingPreservedSegments.push(preserved);
+    }
   }
   const numToStrip = Math.min(count, pathSegments.length);
   const remainingBodySegments = pathSegments.slice(numToStrip);
@@ -679,8 +708,14 @@ async function stripPathSegmentsInDirectory({
   alias = "",
   extensionsToProcess = EXTENSIONS
 }) {
-  log(`[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`);
-  log(`  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`);
+  logger(
+    () => `[stripPathSegmentsInDirectory] Processing directory: ${targetDir}`,
+    true
+  );
+  logger(
+    () => `  - segmentsToStrip: ${segmentsToStrip}, alias: ${alias}`,
+    true
+  );
   try {
     const entries = await fs.readdir(targetDir, { withFileTypes: true });
     const results = [];
@@ -704,6 +739,7 @@ async function stripPathSegmentsInDirectory({
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
+            if (!importPath) continue;
             if (!importPath.includes(SLASH)) {
               continue;
             }
@@ -735,19 +771,19 @@ async function stripPathSegmentsInDirectory({
       })
     );
     if (results.length > 0) {
-      log("[stripPathSegmentsInDirectory] Summary of changes:");
+      logger(() => "[stripPathSegmentsInDirectory] Summary of changes:", true);
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        log(`  in ${displayPath}:`);
+        logger(() => `  in ${displayPath}:`, true);
         for (const { from, to } of changes) {
-          log(`    - ${from} \u2192 ${to}`);
+          logger(() => `    - ${from} \u2192 ${to}`, true);
         }
       }
     } else {
     }
     return results;
   } catch (error) {
-    log(
+    logger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -818,6 +854,7 @@ async function attachPathSegmentsInDirectory({
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
+            if (!importPath) continue;
             if (!importPath.includes(SLASH)) continue;
             const modifiedPath = attachPathSegments(
               importPath,
@@ -841,18 +878,21 @@ async function attachPathSegmentsInDirectory({
       })
     );
     if (results.length > 0) {
-      log("\n[attachPathSegmentsInDirectory] Summary of changes:");
+      logger(
+        () => "\n[attachPathSegmentsInDirectory] Summary of changes:",
+        true
+      );
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
-        log(`  in ${displayPath}:`);
+        logger(() => `  in ${displayPath}:`, true);
         for (const { from, to } of changes) {
-          log(`    - ${from} \u2192 ${to}`);
+          logger(() => `    - ${from} \u2192 ${to}`, true);
         }
       }
     }
     return results;
   } catch (error) {
-    log(
+    logger(
       `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
     );
     return [];
@@ -944,6 +984,7 @@ export {
   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.5",
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@eslint/js": "^9.27.0",
-    "@reliverse/dler": "^1.4.6",
-    "@reliverse/relifso": "^1.2.10",
-    "@reliverse/relinka": "^1.4.6",
-    "@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.7",
+  "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"
   },