@plumeria/utils 19.2.3 → 19.2.5

package/dist/resolver.js

@@ -37,41 +37,240 @@ exports.resetImportResolutionCache = resetImportResolutionCache;
 exports.resolveImportPath = resolveImportPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-let cachedTsConfig = undefined;
-function resetImportResolutionCache(cwd = process.cwd()) {
-    const configPath = path.join(cwd, 'tsconfig.json');
+const CONFIG_DIR = '${configDir}';
+let cachedPathsMatcher = undefined;
+function stripComments(text) {
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (char === '\\') {
+                out += char + (text[i + 1] ?? '');
+                i++;
+                continue;
+            }
+            if (char === '"')
+                inString = false;
+            out += char;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            out += char;
+            continue;
+        }
+        if (char === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            out += '\n';
+            continue;
+        }
+        if (char === '/' && text[i + 1] === '*') {
+            i += 2;
+            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
+                i++;
+            i++;
+            out += ' ';
+            continue;
+        }
+        out += char;
+    }
+    return out;
+}
+function stripTrailingCommas(text) {
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (char === '\\') {
+                out += char + (text[i + 1] ?? '');
+                i++;
+                continue;
+            }
+            if (char === '"')
+                inString = false;
+            out += char;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            out += char;
+            continue;
+        }
+        if (char === ',') {
+            let next = i + 1;
+            while (next < text.length && /\s/.test(text[next]))
+                next++;
+            if (text[next] === '}' || text[next] === ']')
+                continue;
+        }
+        out += char;
+    }
+    return out;
+}
+function readConfig(configPath) {
+    let text;
     try {
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        cachedTsConfig = {
-            config: config.compilerOptions || null,
-            basePath: path.dirname(configPath),
-        };
+        text = fs.readFileSync(configPath, 'utf8');
     }
     catch {
-        cachedTsConfig = null;
+        return null;
+    }
+    try {
+        const config = JSON.parse(stripTrailingCommas(stripComments(text.replace(/^\uFEFF/, ''))));
+        return config && typeof config === 'object' ? config : null;
+    }
+    catch {
+        return null;
     }
 }
-function getTsConfig() {
-    if (cachedTsConfig !== undefined) {
-        return cachedTsConfig;
+function configFileAt(candidate) {
+    return fs.statSync(candidate, { throwIfNoEntry: false })?.isDirectory()
+        ? path.join(candidate, 'tsconfig.json')
+        : candidate;
+}
+function packageNameOf(specifier) {
+    const segments = specifier.split('/');
+    return specifier.startsWith('@')
+        ? segments.slice(0, 2).join('/')
+        : segments[0];
+}
+function resolveQuietly(specifier, basePath) {
+    try {
+        return require.resolve(specifier, { paths: [basePath] });
     }
-    const tsConfigPath = path.join(process.cwd(), 'tsconfig.json');
-    if (fs.existsSync(tsConfigPath)) {
-        try {
-            const config = require(tsConfigPath);
-            cachedTsConfig = {
-                config: config.compilerOptions || null,
-                basePath: path.dirname(tsConfigPath),
-            };
-        }
-        catch {
-            cachedTsConfig = null;
-        }
+    catch {
+        return null;
+    }
+}
+function resolveExtendsPath(specifier, basePath) {
+    if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
+        const resolved = configFileAt(path.resolve(basePath, specifier));
+        if (isFile(resolved))
+            return resolved;
+        const withExtension = resolved + '.json';
+        return isFile(withExtension) ? withExtension : null;
+    }
+    const packageName = packageNameOf(specifier);
+    const exported = () => {
+        const resolved = resolveQuietly(specifier, basePath);
+        return resolved?.endsWith('.json') ? resolved : null;
+    };
+    if (specifier !== packageName)
+        return exported();
+    const manifestPath = resolveQuietly(`${packageName}/package.json`, basePath);
+    if (!manifestPath)
+        return exported();
+    const manifest = readConfig(manifestPath);
+    if (manifest?.exports !== undefined) {
+        const resolved = exported();
+        if (resolved)
+            return resolved;
+    }
+    const packageDir = path.dirname(manifestPath);
+    if (typeof manifest?.tsconfig === 'string') {
+        const declared = configFileAt(path.resolve(packageDir, manifest.tsconfig));
+        if (isFile(declared))
+            return declared;
+    }
+    const fallback = path.join(packageDir, 'tsconfig.json');
+    return isFile(fallback) ? fallback : null;
+}
+function patternsOf(paths, basePath, entryPath) {
+    if (!paths || typeof paths !== 'object')
+        return null;
+    const patterns = [];
+    for (const [alias, targets] of Object.entries(paths)) {
+        if (!Array.isArray(targets) || targets.length === 0)
+            continue;
+        const written = targets.filter((target) => typeof target === 'string');
+        if (written.length === 0)
+            continue;
+        const star = alias.indexOf('*');
+        patterns.push({
+            prefix: star < 0 ? alias : alias.slice(0, star),
+            suffix: star < 0 ? '' : alias.slice(star + 1),
+            wildcard: star >= 0,
+            basePath,
+            targets: written.map((target) => target.startsWith(CONFIG_DIR)
+                ? path.join(entryPath, target.slice(CONFIG_DIR.length))
+                : target),
+        });
     }
-    else {
-        cachedTsConfig = null;
+    return patterns;
+}
+function collectPatterns(configPath, seen, entryPath = path.dirname(configPath)) {
+    if (seen.has(configPath))
+        return null;
+    seen.add(configPath);
+    const config = readConfig(configPath);
+    if (!config)
+        return null;
+    const basePath = path.dirname(configPath);
+    const own = patternsOf(config.compilerOptions?.paths, basePath, entryPath);
+    if (own)
+        return own;
+    const inherited = Array.isArray(config.extends)
+        ? config.extends.slice().reverse()
+        : config.extends
+            ? [config.extends]
+            : [];
+    for (const specifier of inherited) {
+        const resolved = resolveExtendsPath(specifier, basePath);
+        if (!resolved)
+            continue;
+        const patterns = collectPatterns(resolved, seen, entryPath);
+        if (patterns)
+            return patterns;
+    }
+    for (const reference of config.references ?? []) {
+        if (!reference?.path)
+            continue;
+        const patterns = collectPatterns(configFileAt(path.resolve(basePath, reference.path)), seen);
+        if (patterns)
+            return patterns;
     }
-    return cachedTsConfig;
+    return null;
+}
+function buildMatcher(patterns) {
+    const exact = patterns.filter((pattern) => !pattern.wildcard);
+    const wildcard = patterns
+        .filter((pattern) => pattern.wildcard)
+        .sort((a, b) => b.prefix.length - a.prefix.length);
+    return (specifier) => {
+        for (const pattern of exact) {
+            if (pattern.prefix === specifier) {
+                return pattern.targets.map((target) => path.resolve(pattern.basePath, target));
+            }
+        }
+        for (const pattern of wildcard) {
+            if (specifier.length >= pattern.prefix.length + pattern.suffix.length &&
+                specifier.startsWith(pattern.prefix) &&
+                specifier.endsWith(pattern.suffix)) {
+                const matched = specifier.slice(pattern.prefix.length, specifier.length - pattern.suffix.length);
+                return pattern.targets.map((target) => path.resolve(pattern.basePath, target.replace('*', matched)));
+            }
+        }
+        return [];
+    };
+}
+function loadPathsMatcher(configPath) {
+    const patterns = collectPatterns(configPath, new Set());
+    return patterns ? buildMatcher(patterns) : null;
+}
+function resetImportResolutionCache(cwd = process.cwd()) {
+    cachedPathsMatcher = loadPathsMatcher(path.join(cwd, 'tsconfig.json'));
+}
+function getPathsMatcher() {
+    if (cachedPathsMatcher !== undefined)
+        return cachedPathsMatcher;
+    const tsConfigPath = path.join(process.cwd(), 'tsconfig.json');
+    cachedPathsMatcher = fs.existsSync(tsConfigPath)
+        ? loadPathsMatcher(tsConfigPath)
+        : null;
+    return cachedPathsMatcher;
 }
 const extensions = [
     '.ts',
@@ -83,12 +282,22 @@ const extensions = [
     '/index.js',
     '/index.jsx',
 ];
+const rewritten = {
+    '.js': ['.ts', '.tsx'],
+    '.jsx': ['.tsx'],
+};
 function isFile(candidate) {
     return fs.statSync(candidate, { throwIfNoEntry: false })?.isFile() ?? false;
 }
 function resolveWithExtension(basePath) {
     if (isFile(basePath))
         return basePath;
+    const extension = path.extname(basePath);
+    for (const replacement of rewritten[extension] ?? []) {
+        const candidate = basePath.slice(0, -extension.length) + replacement;
+        if (isFile(candidate))
+            return candidate;
+    }
     for (const ext of extensions) {
         const fullPath = basePath + ext;
         if (isFile(fullPath))
@@ -102,21 +311,12 @@ function resolveImportPath(importPath, importerPath) {
     if (importPath.startsWith('.')) {
         return resolveWithExtension(path.resolve(path.dirname(importerPath), importPath));
     }
-    const tsConfig = getTsConfig();
-    const config = tsConfig?.config;
-    if (config?.paths) {
-        const root = tsConfig.basePath;
-        for (const [alias, targets] of Object.entries(config.paths)) {
-            const prefix = alias.replace(/\*$/, '');
-            if (importPath.startsWith(prefix)) {
-                for (const target of targets) {
-                    const resolvedTarget = target.replace(/\*$/, '');
-                    const candidate = path.resolve(root, resolvedTarget + importPath.slice(prefix.length));
-                    const result = resolveWithExtension(candidate);
-                    if (result)
-                        return result;
-                }
-            }
+    const matchPaths = getPathsMatcher();
+    if (matchPaths) {
+        for (const candidate of matchPaths(importPath)) {
+            const result = resolveWithExtension(candidate);
+            if (result)
+                return result;
         }
     }
     let currentDir = path.dirname(importerPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "19.2.3",
+  "version": "19.2.5",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",