@getmikk/core 1.8.1 → 1.8.3

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

@@ -22,9 +22,10 @@ export class JavaScriptExtractor extends TypeScriptExtractor {
     /** ESM functions + module.exports-assigned functions */
     override extractFunctions(): ParsedFunction[] {
         const fns = super.extractFunctions()
-        const seen = new Set(fns.map(f => f.name))
+        // Use id (which includes start line) to avoid false deduplication
+        const seen = new Set(fns.map(f => f.id))
         for (const fn of this.extractCommonJsFunctions()) {
-            if (!seen.has(fn.name)) { fns.push(fn); seen.add(fn.name) }
+            if (!seen.has(fn.id)) { fns.push(fn); seen.add(fn.id) }
         }
         return fns
     }
@@ -42,9 +43,15 @@ export class JavaScriptExtractor extends TypeScriptExtractor {
     /** ESM exports + CommonJS module.exports / exports.x */
     override extractExports(): ParsedExport[] {
         const esm = super.extractExports()
-        const seen = new Set(esm.map(e => e.name))
+        // Index by name; for default exports use type as secondary key to avoid
+        // a local function named 'default' from being incorrectly matched.
+        const seen = new Map(esm.map(e => [`${e.name}:${e.type}`, true]))
         for (const exp of this.extractCommonJsExports()) {
-            if (!seen.has(exp.name)) { esm.push(exp); seen.add(exp.name) }
+            const key = `${exp.name}:${exp.type}`
+            if (!seen.has(key)) {
+                esm.push(exp)
+                seen.set(key, true)
+            }
         }
         return esm
     }
@@ -91,11 +98,20 @@ export class JavaScriptExtractor extends TypeScriptExtractor {
     private getRequireBindingNames(call: ts.CallExpression): string[] {
         const parent = call.parent
         if (!parent || !ts.isVariableDeclaration(parent)) return []
-        // const { a, b } = require('...') → ['a', 'b']
+        // const { a: myA, b } = require('...') → ['a', 'b'] (use the SOURCE name, not the alias)
+        // The source name (propertyName) is what the module exports.
+        // The local alias (element.name) is only visible in this file.
         if (ts.isObjectBindingPattern(parent.name)) {
             return parent.name.elements
                 .filter(e => ts.isIdentifier(e.name))
-                .map(e => (e.name as ts.Identifier).text)
+                .map(e => {
+                    // If there is a property name (the "a" in "a: myA"), use it.
+                    // Otherwise the binding uses the same name for both sides.
+                    if (e.propertyName && ts.isIdentifier(e.propertyName)) {
+                        return e.propertyName.text
+                    }
+                    return (e.name as ts.Identifier).text
+                })
         }
         // const x = require('...') → ['x']
         if (ts.isIdentifier(parent.name)) return [parent.name.text]

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

@@ -5,6 +5,7 @@ import { JavaScriptExtractor } from './js-extractor.js'
 import { JavaScriptResolver } from './js-resolver.js'
 import { hashContent } from '../../hash/file-hasher.js'
 import type { ParsedFile } from '../types.js'
+import { MIN_FILES_FOR_COMPLETE_SCAN, parseJsonWithComments } from '../parser-constants.js'
 
 /**
  * JavaScriptParser -- implements BaseParser for .js / .mjs / .cjs / .jsx files.
@@ -18,18 +19,25 @@ export class JavaScriptParser extends BaseParser {
         const extractor = new JavaScriptExtractor(filePath, content)
 
         const functions = extractor.extractFunctions()
-        const classes   = extractor.extractClasses()
-        const generics  = extractor.extractGenerics()
-        const imports   = extractor.extractImports()
-        const exports   = extractor.extractExports()
-        const routes    = extractor.extractRoutes()
+        const classes = extractor.extractClasses()
+        const generics = extractor.extractGenerics()
+        const imports = extractor.extractImports()
+        const exports = extractor.extractExports()
+        const routes = extractor.extractRoutes()
 
         // Cross-reference: CJS exports may mark a name exported even when the
         // declaration itself had no `export` keyword.
-        const exportedNames = new Set(exports.map(e => e.name))
-        for (const fn  of functions) { if (!fn.isExported  && exportedNames.has(fn.name))  fn.isExported  = true }
-        for (const cls of classes)   { if (!cls.isExported && exportedNames.has(cls.name)) cls.isExported = true }
-        for (const gen of generics)  { if (!gen.isExported && exportedNames.has(gen.name)) gen.isExported = true }
+        //
+        // We only mark a symbol as exported when the export list contains an
+        // entry with BOTH a matching name AND a non-default type. This prevents
+        // `module.exports = function() {}` (which produces name='default', type='default')
+        // from accidentally marking an unrelated local function called 'default' as exported.
+        const exportedNonDefault = new Set(
+            exports.filter(e => e.type !== 'default').map(e => e.name)
+        )
+        for (const fn of functions) { if (!fn.isExported && exportedNonDefault.has(fn.name)) fn.isExported = true }
+        for (const cls of classes) { if (!cls.isExported && exportedNonDefault.has(cls.name)) cls.isExported = true }
+        for (const gen of generics) { if (!gen.isExported && exportedNonDefault.has(gen.name)) gen.isExported = true }
 
         return {
             path: filePath,
@@ -47,7 +55,10 @@ export class JavaScriptParser extends BaseParser {
 
     resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
         const aliases = loadAliases(projectRoot)
-        const allFilePaths = files.map(f => f.path)
+        // Only pass the file list when it represents a reasonably complete scan.
+        // A sparse list (< MIN_FILES_FOR_COMPLETE_SCAN files) causes valid alias-resolved
+        // imports to return '' because the target file is not in the partial list.
+        const allFilePaths = files.length >= MIN_FILES_FOR_COMPLETE_SCAN ? files.map(f => f.path) : []
         const resolver = new JavaScriptResolver(projectRoot, aliases)
         return files.map(file => ({
             ...file,
@@ -62,8 +73,7 @@ export class JavaScriptParser extends BaseParser {
 
 /**
  * Load path aliases from jsconfig.json → tsconfig.json → tsconfig.base.json.
- * Strips JS/block comments before parsing (both formats allow them).
- * Falls back to raw content if comment-stripping breaks a URL.
+ * Strips JSON5 comments via the shared helper and falls back to raw content if parsing fails.
  * Returns {} when no config is found.
  */
 function loadAliases(projectRoot: string): Record<string, string[]> {
@@ -71,12 +81,9 @@ function loadAliases(projectRoot: string): Record<string, string[]> {
         const configPath = path.join(projectRoot, name)
         try {
             const raw = fs.readFileSync(configPath, 'utf-8')
-            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
-            let config: any
-            try   { config = JSON.parse(stripped) }
-            catch { config = JSON.parse(raw) }          // URL stripping may have broken JSON
+            const config: any = parseJsonWithComments(raw)
 
-            const options  = config.compilerOptions ?? {}
+            const options = config.compilerOptions ?? {}
             const rawPaths: Record<string, string[]> = options.paths ?? {}
             if (Object.keys(rawPaths).length === 0) continue
 

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)
+    }
+}