@getmikk/core 1.8.0 → 1.8.2

package/src/parser/javascript/js-resolver.ts

@@ -7,11 +7,15 @@ import type { ParsedImport } from '../types.js'
  * Handles:
  *   - Relative ESM imports:  import './utils'  →  ./utils.js / ./utils/index.js / ...
  *   - CommonJS require():    require('./db')    →  same resolution order
- *   - Path aliases from jsconfig.json / tsconfig.json
+ *   - Path aliases from jsconfig.json / tsconfig.json (all targets tried, not just first)
  *   - Mixed TS/JS projects: falls back to .ts/.tsx if no JS file matched
  *
  * Extension probe order: .js → .jsx → .mjs → .cjs → index.js → index.jsx →
  *                         .ts → .tsx → index.ts → index.tsx
+ *
+ * Performance: allProjectFiles is converted to a Set internally for O(1) membership
+ * checks. Pass the same array every call — the Set is built per-call and is cheap
+ * for the sizes we deal with, or cache the Set externally and pass it directly.
  */
 export class JavaScriptResolver {
     constructor(
@@ -28,39 +32,77 @@ export class JavaScriptResolver {
         ) {
             return { ...imp, resolvedPath: '' }
         }
-        return { ...imp, resolvedPath: this.resolvePath(imp.source, fromFile, allProjectFiles) }
+        // Build Set once per resolve call. For large repos callers should cache this.
+        const fileSet = allProjectFiles.length > 0 ? new Set(allProjectFiles) : null
+        return { ...imp, resolvedPath: this.resolvePath(imp.source, fromFile, fileSet) }
     }
 
     resolveAll(imports: ParsedImport[], fromFile: string, allProjectFiles: string[] = []): ParsedImport[] {
-        return imports.map(imp => this.resolve(imp, fromFile, allProjectFiles))
+        // Build Set once for the entire batch — O(n) instead of O(n * imports * probes)
+        const fileSet = allProjectFiles.length > 0 ? new Set(allProjectFiles) : null
+        return imports.map(imp => {
+            if (
+                !imp.source.startsWith('.') &&
+                !imp.source.startsWith('/') &&
+                !this.matchesAlias(imp.source)
+            ) {
+                return { ...imp, resolvedPath: '' }
+            }
+            return { ...imp, resolvedPath: this.resolvePath(imp.source, fromFile, fileSet) }
+        })
     }
 
-    private resolvePath(source: string, fromFile: string, allProjectFiles: string[]): string {
-        let resolvedSource = source
-
-        // 1. Alias substitution
+    private resolvePath(source: string, fromFile: string, fileSet: Set<string> | null): string {
+        // 1. Alias substitution — try ALL targets in order, not just targets[0]
         for (const [alias, targets] of Object.entries(this.aliases)) {
             const prefix = alias.replace('/*', '')
             if (source.startsWith(prefix)) {
-                resolvedSource = targets[0].replace('/*', '') + source.slice(prefix.length)
-                break
+                for (const target of targets) {
+                    const substituted = target.replace('/*', '') + source.slice(prefix.length)
+                    const resolved = this.normalizePath(substituted, fromFile)
+                    const found = this.probeExtensions(resolved, fileSet)
+                    if (found) return found
+                }
+                // All alias targets failed — fall through to return unresolved indicator
+                // rather than silently returning a path that doesn't exist
+                return ''
             }
         }
 
-        // 2. Build absolute-like posix path
+        // 2. Build absolute-like posix path from relative source
+        const resolved = this.normalizePath(source, fromFile)
+
+        // 3. Already has a concrete extension — validate existence and return
+        const knownExts = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx']
+        if (knownExts.some(e => resolved.endsWith(e))) {
+            // If we have a file list, validate the path exists in it
+            if (fileSet && !fileSet.has(resolved)) return ''
+            return resolved
+        }
+
+        // 4. Probe extensions in priority order
+        return this.probeExtensions(resolved, fileSet) ?? ''
+    }
+
+    /** Normalize a source path to a posix-style project-relative path */
+    private normalizePath(source: string, fromFile: string): string {
         let resolved: string
-        if (resolvedSource.startsWith('.')) {
-            resolved = path.posix.normalize(path.posix.join(path.dirname(fromFile), resolvedSource))
+        if (source.startsWith('.')) {
+            resolved = path.posix.normalize(
+                path.posix.join(path.dirname(fromFile.replace(/\\/g, '/')), source)
+            )
         } else {
-            resolved = resolvedSource
+            resolved = source
         }
-        resolved = resolved.replace(/\\/g, '/')
-
-        // 3. Already has a concrete extension — return as-is
-        const knownExts = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx']
-        if (knownExts.some(e => resolved.endsWith(e))) return resolved
+        return resolved.replace(/\\/g, '/')
+    }
 
-        // 4. Probe extensions: prefer JS-family first, fall back to TS for mixed projects
+    /**
+     * Probe file extensions in priority order.
+     * Returns the first candidate that exists in the file set,
+     * or the first candidate if no file set is provided (legacy behaviour).
+     */
+    private probeExtensions(resolved: string, fileSet: Set<string> | null): string | null {
         const probeOrder = [
             '.js', '.jsx', '.mjs', '.cjs',
             '/index.js', '/index.jsx', '/index.mjs',
@@ -69,12 +111,11 @@ export class JavaScriptResolver {
         ]
         for (const ext of probeOrder) {
             const candidate = resolved + ext
-            if (allProjectFiles.length === 0 || allProjectFiles.includes(candidate)) {
+            if (fileSet === null || fileSet.has(candidate)) {
                 return candidate
             }
         }
-
-        return resolved + '.js'
+        return null
     }
 
     private matchesAlias(source: string): boolean {

package/src/parser/parser-constants.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared parser utilities/constants.
+ * Keeps common thresholds and comment-stripping helpers in one place so
+ * JavaScript and TypeScript parsers behave consistently.
+ */
+
+/** Files count threshold that signals a reasonably complete project scan. */
+export const MIN_FILES_FOR_COMPLETE_SCAN = 10
+
+/**
+ * Remove JSON5-style comments while preserving string literals.
+ * Handles single/double/backtick strings plus escaped characters.
+ */
+export function stripJsonComments(raw: string): string {
+    let result = ''
+    let i = 0
+    let stringChar: string | null = null
+    let escaped = false
+
+    while (i < raw.length) {
+        const char = raw[i]
+        const next = i + 1 < raw.length ? raw[i + 1] : ''
+
+        if (stringChar) {
+            result += char
+            if (escaped) {
+                escaped = false
+            } else if (char === '\\') {
+                escaped = true
+            } else if (char === stringChar) {
+                stringChar = null
+            }
+            i += 1
+            continue
+        }
+
+        if (char === '"' || char === "'" || char === '`') {
+            stringChar = char
+            result += char
+            i += 1
+            continue
+        }
+
+        if (char === '/' && next === '*') {
+            i += 2
+            while (i < raw.length) {
+                if (raw[i] === '*' && raw[i + 1] === '/') {
+                    i += 2
+                    break
+                }
+                i += 1
+            }
+            continue
+        }
+
+        if (char === '/' && next === '/') {
+            i += 2
+            while (i < raw.length && raw[i] !== '\n' && raw[i] !== '\r') {
+                i += 1
+            }
+            continue
+        }
+
+        result += char
+        i += 1
+    }
+
+    return result
+}
+
+/**
+ * Parse JSON config files while tolerating JSON5 comments.
+ * Falls back to the raw content if comment stripping breaks URLs.
+ */
+export function parseJsonWithComments<T = any>(raw: string): T {
+    const stripped = stripJsonComments(raw)
+    try {
+        return JSON.parse(stripped)
+    } catch {
+        return JSON.parse(raw)
+    }
+}