rwsdk/dist/vite/moduleResolver.mjs

Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime

import path from "path";
import enhancedResolve from "enhanced-resolve";
import debug from "debug";
function applyAlias(request, aliasEntries, name) {
    if (!aliasEntries)
        return request;
    const logPrefix = `:${name}:`;
    // Support both array and object forms
    const entries = Array.isArray(aliasEntries)
        ? aliasEntries
        : Object.entries(aliasEntries).map(([find, replacement]) => ({
            find,
            replacement,
        }));
    for (const entry of entries) {
        const { find, replacement } = entry;
        if (typeof find === "string") {
            if (request === find || request.startsWith(find + "/")) {
                debug("rwsdk:vite:aliased-module-resolver")("%s :applyAlias: Matched string alias: '%s' -> '%s' for request '%s'", logPrefix, find, replacement, request);
                return replacement + request.slice(find.length);
            }
        }
        else if (find instanceof RegExp) {
            if (find.test(request)) {
                debug("rwsdk:vite:aliased-module-resolver")("%s :applyAlias: Matched RegExp alias: %O -> '%s' for request '%s'", logPrefix, find, replacement, request);
                return request.replace(find, replacement);
            }
        }
    }
    return request;
}
export function createModuleResolver({ getAliases, roots, conditionNames = ["workerd", "edge", "import", "default"], name, }) {
    const log = debug("rwsdk:vite:aliased-module-resolver");
    const logPrefix = `:${name}:`;
    const baseModuleResolver = enhancedResolve.create.sync({
        conditionNames,
        extensions: [".mjs", ".js", ".ts", ".jsx", ".tsx"],
    });
    const attemptResolve = (from, request) => {
        try {
            return baseModuleResolver(from, request);
        }
        catch {
            return false;
        }
    };
    return function resolveModule(request, importer) {
        log("%s Called with request=%s, importer=%s", logPrefix, request, importer);
        const aliasEntries = getAliases ? getAliases() : [];
        const normalized = applyAlias(request, aliasEntries, name);
        log("%s After aliasing: %s", logPrefix, normalized);
        if (importer != null) {
            const result = attemptResolve(path.dirname(importer), normalized);
            if (result) {
                log("%s Resolved module=%s relative to: importer=%s", logPrefix, result, importer);
                return result;
            }
        }
        for (const root of roots) {
            try {
                log("%s Attempting to resolve module=%s relative to: root=%s", logPrefix, normalized, root);
                const result = attemptResolve(root, normalized);
                if (result) {
                    log("%s Resolved module=%s relative to: root=%s", logPrefix, result, importer);
                    return result;
                }
            }
            catch (err) {
                log("%s Resolution failed for normalized=%s from root=%s: %O", logPrefix, normalized, root, err);
            }
        }
        return false;
    };
}