entkapp 4.5.1 → 5.1.0

package/src/resolution/PathMapper.js

@@ -1,125 +1,49 @@
-import fs from 'fs/promises';
+import fs from 'fs';
 import path from 'path';
 
-/**
- * Advanced TSConfig / JSConfig Compilation Path Alias Mapper
- * Resolves deeply nested route mappings, wildcards, and base URL overrides.
- */
 export class PathMapper {
-  constructor(context) {
-    this.context = context;
-    this.baseUrl = '.';
-    this.absoluteBaseUrl = context.cwd;
-    this.mappings = []; // Collection of { prefix, suffix, targets[] }
+  constructor(context) { 
+    this.context = context; 
   }
-
-  /**
-   * Reads, cleans, and indexes custom alias entries from tsconfig.json files.
-   * @param {string} tsconfigFilename - Target designator (typically tsconfig.json)
-   */
-  async loadMappings(tsconfigFilename = 'tsconfig.json') {
-    const configPath = path.resolve(this.context.cwd, tsconfigFilename);
-    
-    try {
-      await fs.access(configPath);
-      const rawText = await fs.readFile(configPath, 'utf8');
-      
-      // Strip inline single-line and block comments before parsing
-      // Improved regex to handle more edge cases in tsconfig comments
-      const jsonCleanText = rawText
-        .replace(/\/\*[\s\S]*?\*\/|(?<=[^\\:])\/\/.*$/gm, '')
-        .replace(/,(\s*[\]}])/g, '$1'); // Remove trailing commas
-        
-      const tsconfig = JSON.parse(jsonCleanText);
-
-      if (!tsconfig.compilerOptions) return;
-
-      const opts = tsconfig.compilerOptions;
-      
-      // v6 Path Resolution Fix (Knip Issue #1794)
-      // Ensure baseUrl is correctly resolved relative to the tsconfig file location
-      const configDir = path.dirname(configPath);
-      if (opts.baseUrl) {
-        this.baseUrl = opts.baseUrl;
-        this.absoluteBaseUrl = path.resolve(configDir, this.baseUrl);
-      } else {
-        this.absoluteBaseUrl = configDir;
-      }
-
-      if (opts.paths) {
-        for (const [aliasPattern, targetArrays] of Object.entries(opts.paths)) {
-          this.registerPatternRule(aliasPattern, targetArrays);
-        }
-      }
-    } catch (error) {
-      if (this.context.verbose) {
-        console.warn(`⚠️ [PathMapper Override] Proceeding without custom path configurations. Source: ${error.message}`);
-      }
-    }
+  
+  async loadMappings() {
+    // Hier können später tsconfig-Pfade geladen werden
   }
 
   /**
-   * Registers structural lookup parameters for alias strings.
+   * Resolves physical module paths on disk, translating modern .js imports 
+   * back to their actual TypeScript source files.
+   * @param {string} p - The target module specifier or absolute path
    */
-  registerPatternRule(pattern, targets) {
-    const wildcardIndex = pattern.indexOf('*');
+  resolvePath(p) {
+    if (!p || typeof p !== 'string') return p;
 
-    if (wildcardIndex === -1) {
-      this.mappings.push({
-        isExact: true,
-        pattern,
-        targets: targets.map(t => path.normalize(t))
-      });
-      return;
+    // FIX 1: Wenn der Import auf .js endet, übersetze ihn für die Suche auf .ts
+    if (p.endsWith('.js')) {
+      const tsPath = p.slice(0, -3) + '.ts';
+      if (fs.existsSync(tsPath)) return tsPath;
     }
 
-    const prefix = pattern.slice(0, wildcardIndex);
-    const suffix = pattern.slice(wildcardIndex + 1);
-
-    this.mappings.push({
-      isExact: false,
-      prefix,
-      suffix,
-      targets: targets.map(t => path.normalize(t))
-    });
-  }
-
-  /**
-   * Resolves a raw import specifier against mapped path patterns.
-   * @param {string} specifier - Raw text from import declaration (e.g., '@ui/button')
-   * @returns {Array<string>} Candidates of absolute filesystem paths to try resolving
-   */
-  resolveCandidatePaths(specifier) {
-    const matchingCandidates = [];
-
-    for (const rule of this.mappings) {
-      if (rule.isExact) {
-        if (specifier === rule.pattern) {
-          rule.targets.forEach(target => {
-            matchingCandidates.push(path.resolve(this.absoluteBaseUrl, target));
-          });
-        }
-      } else {
-        // Evaluate wildcard pattern matches
-        if (specifier.startsWith(rule.prefix) && specifier.endsWith(rule.suffix)) {
-          const extractedWildcardContent = specifier.slice(
-            rule.prefix.length,
-            specifier.length - rule.suffix.length
-          );
+    // FIX 2: Wenn der Import auf .jsx endet, übersetze ihn für die Suche auf .tsx
+    if (p.endsWith('.jsx')) {
+      const tsxPath = p.slice(0, -4) + '.tsx';
+      if (fs.existsSync(tsxPath)) return tsxPath;
+    }
 
-          rule.targets.forEach(targetTemplate => {
-            const interpolatedTarget = targetTemplate.replace('*', extractedWildcardContent);
-            matchingCandidates.push(path.resolve(this.absoluteBaseUrl, interpolatedTarget));
-          });
+    // FIX 3: Unterstützung für Verzeichnis-Imports (z.B. ./adapters -> ./adapters/index.ts)
+    try {
+      const stat = fs.statSync(p);
+      if (stat.isDirectory()) {
+        const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+        for (const ext of extensions) {
+          const indexPath = path.join(p, `index${ext}`);
+          if (fs.existsSync(indexPath)) return indexPath;
         }
       }
+    } catch {
+      // Datei existiert nicht oder ist kein Verzeichnis, fahre mit Standard fort
     }
 
-    // Fall back to direct lookup relative to the base URL
-    if (!specifier.startsWith('.') && !path.isAbsolute(specifier)) {
-      matchingCandidates.push(path.resolve(this.absoluteBaseUrl, specifier));
-    }
-
-    return matchingCandidates;
+    return p; 
   }
 }

package/src/resolution/TSConfigLoader.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+
+export class TSConfigLoader {
+    constructor(targetDir) {
+        this.targetDir = targetDir;
+    }
+
+    /**
+     * Lädt und parst die tsconfig.json.
+     * @returns {Object|null} Parsed config oder null.
+     */
+    load() {
+        const configPath = path.join(this.targetDir, 'tsconfig.json');
+        if (!fs.existsSync(configPath)) return null;
+
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const result = ts.parseConfigFileTextWithComments(configPath, content);
+            
+            if (result.error) {
+                return null;
+            }
+
+            const parsed = ts.parseJsonConfigFileContent(
+                result.config,
+                ts.sys,
+                this.targetDir
+            );
+
+            return parsed;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    /**
+     * Erstellt eine Mapping-Funktion für Aliases aus der tsconfig.
+     * @param {Object} parsedConfig 
+     * @returns {Function} Mapper function.
+     */
+    getAliasMapper(parsedConfig) {
+        if (!parsedConfig || !parsedConfig.options || !parsedConfig.options.paths) {
+            return (source) => source;
+        }
+
+        const { paths, baseUrl } = parsedConfig.options;
+        const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
+
+        return (source) => {
+            for (const pattern in paths) {
+                const regexPattern = pattern.replace(/\*/, '(.*)');
+                const regex = new RegExp(`^${regexPattern}$`);
+                const match = source.match(regex);
+
+                if (match) {
+                    const replacements = paths[pattern];
+                    for (const replacement of replacements) {
+                        const resolvedReplacement = replacement.replace(/\*/, match[1]);
+                        const fullPath = path.resolve(base, resolvedReplacement);
+                        
+                        // Prüfe ob Datei existiert
+                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+                        for (const ext of extensions) {
+                            if (fs.existsSync(fullPath + ext)) {
+                                return fullPath + ext;
+                            }
+                        }
+                    }
+                }
+            }
+            return source;
+        };
+    }
+}