@supernovaio/cli/dist/utils/module-resolution.js

Supernova.io Command Line Interface

!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="de233e0b-b94f-59be-b508-f134959bd583")}catch(e){}}();
import fs from "node:fs";
import path from "node:path";
export const packageEntryFieldPriority = ["source", "module", "jsnext:main", "browser", "main", "types", "typings"];
export const packageDeclarationEntryFieldPriority = [
    "types",
    "typings",
    "source",
    "module",
    "jsnext:main",
    "browser",
    "main",
];
export const exportConditionPriority = [
    "source",
    "import",
    "module",
    "browser",
    "development",
    "production",
    "default",
    "require",
    "types",
    "typings",
];
export const exportDeclarationConditionPriority = [
    "types",
    "typings",
    "source",
    "import",
    "module",
    "browser",
    "development",
    "production",
    "default",
    "require",
];
export const sourceModuleFileExtensions = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
export const declarationModuleFileExtensions = [".d.ts", ".d.mts", ".d.cts"];
export const sourceIndexEntryFileNames = [
    "index.ts",
    "index.tsx",
    "index.mts",
    "index.cts",
    "index.js",
    "index.jsx",
    "index.mjs",
    "index.cjs",
];
export const indexEntryFileNames = [
    ...sourceIndexEntryFileNames,
    "index.d.ts",
    "index.d.mts",
    "index.d.cts",
];
export const declarationPreferredIndexEntryFileNames = [
    "index.d.ts",
    "index.d.mts",
    "index.d.cts",
    ...sourceIndexEntryFileNames,
];
export function isRecord(value) {
    return typeof value === "object" && value !== null && !Array.isArray(value);
}
export function normalizePath(value) {
    return value.replaceAll("\\", "/");
}
export function isDeclarationModuleFile(filePath) {
    return declarationModuleFileExtensions.some(extension => filePath.endsWith(extension));
}
function moduleFileExtensionsFor(options = {}) {
    if (options.allowDeclarations === false) {
        return sourceModuleFileExtensions;
    }
    return options.preferDeclarations
        ? [...declarationModuleFileExtensions, ...sourceModuleFileExtensions]
        : [...sourceModuleFileExtensions, ...declarationModuleFileExtensions];
}
function indexFileNamesFor(options = {}) {
    const fileNames = options.preferDeclarations ? declarationPreferredIndexEntryFileNames : indexEntryFileNames;
    return options.allowDeclarations === false
        ? fileNames.filter(fileName => !isDeclarationModuleFile(fileName))
        : fileNames;
}
function stripKnownModuleExtension(filePath) {
    const knownExtensions = [...declarationModuleFileExtensions, ...sourceModuleFileExtensions];
    const extension = knownExtensions.find(candidate => filePath.endsWith(candidate));
    return extension ? filePath.slice(0, -extension.length) : filePath;
}
export function resolveExistingModuleFile(entryPath, options = {}) {
    if (fs.existsSync(entryPath)) {
        const stats = fs.statSync(entryPath);
        if (stats.isFile()) {
            return options.allowDeclarations === false && isDeclarationModuleFile(entryPath) ? null : entryPath;
        }
        if (stats.isDirectory()) {
            for (const entryFileName of indexFileNamesFor(options)) {
                const candidate = path.join(entryPath, entryFileName);
                if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
                    return candidate;
                }
            }
            return null;
        }
    }
    const basePath = stripKnownModuleExtension(entryPath);
    const candidates = moduleFileExtensionsFor(options).map(extension => `${basePath}${extension}`);
    for (const candidate of new Set(candidates)) {
        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
            return candidate;
        }
    }
    return null;
}
export function readPackageJson(packageDir) {
    const packageJsonPath = path.join(packageDir, "package.json");
    if (!fs.existsSync(packageJsonPath)) {
        return null;
    }
    try {
        return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
    }
    catch {
        return null;
    }
}
export function rootExportValue(exportsField) {
    if (!isRecord(exportsField)) {
        return exportsField;
    }
    if (Object.hasOwn(exportsField, ".")) {
        return exportsField["."];
    }
    if (Object.keys(exportsField).some(key => key.startsWith("."))) {
        return undefined;
    }
    return exportsField;
}
export function targetCandidates(value, conditionPriority = exportConditionPriority) {
    if (typeof value === "string") {
        return [value];
    }
    if (Array.isArray(value)) {
        return value.flatMap(item => targetCandidates(item, conditionPriority));
    }
    if (!isRecord(value)) {
        return [];
    }
    const conditionPrioritySet = new Set(conditionPriority);
    const orderedValues = [
        ...conditionPriority.map(condition => value[condition]),
        ...Object.entries(value)
            .filter(([condition]) => !conditionPrioritySet.has(condition))
            .map(([, target]) => target),
    ];
    return orderedValues.flatMap(item => targetCandidates(item, conditionPriority));
}
export function exportValueForSubpath(exportsField, subpath) {
    if (subpath === ".") {
        return rootExportValue(exportsField);
    }
    if (!isRecord(exportsField)) {
        return undefined;
    }
    return exportsField[subpath];
}
export function packageJsonEntryCandidates(packageJson, subpath) {
    const exportEntries = targetCandidates(exportValueForSubpath(packageJson.exports, subpath));
    const fieldEntries = subpath === "."
        ? packageEntryFieldPriority
            .map(field => packageJson[field])
            .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
        : [];
    return [...new Set([...exportEntries, ...fieldEntries])].filter(entry => entry.startsWith(".") || !path.isAbsolute(entry));
}
export function resolvePatternTarget(pattern, targetPattern, specifier) {
    if (!pattern.includes("*")) {
        return pattern === specifier ? targetPattern : null;
    }
    const [prefix, suffix] = pattern.split("*");
    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) {
        return null;
    }
    const wildcardValue = specifier.slice(prefix.length, specifier.length - suffix.length);
    return targetPattern.replaceAll("*", wildcardValue);
}
function packageImportMatches(importsField, moduleSpecifier) {
    return Object.entries(importsField)
        .flatMap(([pattern, target]) => {
        const score = packageImportPatternScore(pattern, moduleSpecifier);
        if (score === null) {
            return [];
        }
        return [{ pattern, score, target }];
    })
        .sort((a, b) => b.score - a.score)
        .map(match => [match.pattern, match.target]);
}
function packageImportPatternScore(pattern, moduleSpecifier) {
    if (!pattern.includes("*")) {
        return pattern === moduleSpecifier ? 2000 + pattern.length : null;
    }
    const [prefix, suffix] = pattern.split("*");
    if (!moduleSpecifier.startsWith(prefix) || !moduleSpecifier.endsWith(suffix)) {
        return null;
    }
    return 1000 + prefix.length + suffix.length;
}
function findNearestPackageDir(startPath) {
    let current = path.dirname(startPath);
    while (true) {
        if (fs.existsSync(path.join(current, "package.json"))) {
            return current;
        }
        const parent = path.dirname(current);
        if (parent === current) {
            return null;
        }
        current = parent;
    }
}
export function resolvePackageImportModulePath(containingFilePath, moduleSpecifier) {
    if (!moduleSpecifier.startsWith("#")) {
        return null;
    }
    const packageDir = findNearestPackageDir(containingFilePath);
    if (!packageDir) {
        return null;
    }
    const importsField = readPackageJson(packageDir)?.imports;
    if (!isRecord(importsField)) {
        return null;
    }
    for (const [pattern, targetValue] of packageImportMatches(importsField, moduleSpecifier)) {
        for (const target of targetCandidates(targetValue)) {
            const replacedTarget = resolvePatternTarget(pattern, target, moduleSpecifier);
            if (!replacedTarget || !replacedTarget.startsWith(".")) {
                continue;
            }
            const resolvedPath = resolveExistingModuleFile(path.resolve(packageDir, replacedTarget), {
                preferDeclarations: isDeclarationModuleFile(containingFilePath),
            });
            if (resolvedPath) {
                return resolvedPath;
            }
        }
    }
    return null;
}
export function resolveModuleSpecifierFromFile(containingFilePath, moduleSpecifier) {
    const packageImportPath = resolvePackageImportModulePath(containingFilePath, moduleSpecifier);
    if (packageImportPath) {
        return packageImportPath;
    }
    if (!moduleSpecifier.startsWith(".")) {
        return null;
    }
    return resolveExistingModuleFile(path.resolve(path.dirname(containingFilePath), moduleSpecifier), {
        preferDeclarations: isDeclarationModuleFile(containingFilePath),
    });
}
//# sourceMappingURL=module-resolution.js.map
//# debugId=de233e0b-b94f-59be-b508-f134959bd583