@reliverse/pathkit 1.1.5 → 1.1.6

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;
@@ -219,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, 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"];
@@ -583,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;
@@ -600,6 +604,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);
@@ -944,6 +949,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.6",
+  "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"
   },