ts-node/dist/esm.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createEsmHooks = exports.registerAndCreateEsmHooks = exports.filterHooksByAPIVersion = void 0;
const index_1 = require("./index");
const url_1 = require("url");
const path_1 = require("path");
const assert = require("assert");
const util_1 = require("./util");
const module_1 = require("module");
// The hooks API changed in node version X so we need to check for backwards compatibility.
const newHooksAPI = (0, util_1.versionGteLt)(process.versions.node, '16.12.0');
/** @internal */
function filterHooksByAPIVersion(hooks) {
    const { getFormat, load, resolve, transformSource } = hooks;
    // Explicit return type to avoid TS's non-ideal inferred type
    const hooksAPI = newHooksAPI
        ? { resolve, load, getFormat: undefined, transformSource: undefined }
        : { resolve, getFormat, transformSource, load: undefined };
    return hooksAPI;
}
exports.filterHooksByAPIVersion = filterHooksByAPIVersion;
/** @internal */
function registerAndCreateEsmHooks(opts) {
    // Automatically performs registration just like `-r ts-node/register`
    const tsNodeInstance = (0, index_1.register)(opts);
    return createEsmHooks(tsNodeInstance);
}
exports.registerAndCreateEsmHooks = registerAndCreateEsmHooks;
function createEsmHooks(tsNodeService) {
    tsNodeService.enableExperimentalEsmLoaderInterop();
    // Custom implementation that considers additional file extensions and automatically adds file extensions
    const nodeResolveImplementation = tsNodeService.getNodeEsmResolver();
    const nodeGetFormatImplementation = tsNodeService.getNodeEsmGetFormat();
    const extensions = tsNodeService.extensions;
    const hooksAPI = filterHooksByAPIVersion({
        resolve,
        load,
        getFormat,
        transformSource,
    });
    function isFileUrlOrNodeStyleSpecifier(parsed) {
        // We only understand file:// URLs, but in node, the specifier can be a node-style `./foo` or `foo`
        const { protocol } = parsed;
        return protocol === null || protocol === 'file:';
    }
    /**
     * Named "probably" as a reminder that this is a guess.
     * node does not explicitly tell us if we're resolving the entrypoint or not.
     */
    function isProbablyEntrypoint(specifier, parentURL) {
        return parentURL === undefined && specifier.startsWith('file://');
    }
    // Side-channel between `resolve()` and `load()` hooks
    const rememberIsProbablyEntrypoint = new Set();
    const rememberResolvedViaCommonjsFallback = new Set();
    async function resolve(specifier, context, defaultResolve) {
        const defer = async () => {
            const r = await defaultResolve(specifier, context, defaultResolve);
            return r;
        };
        // See: https://github.com/nodejs/node/discussions/41711
        // nodejs will likely implement a similar fallback.  Till then, we can do our users a favor and fallback today.
        async function entrypointFallback(cb) {
            try {
                const resolution = await cb();
                if ((resolution === null || resolution === void 0 ? void 0 : resolution.url) &&
                    isProbablyEntrypoint(specifier, context.parentURL))
                    rememberIsProbablyEntrypoint.add(resolution.url);
                return resolution;
            }
            catch (esmResolverError) {
                if (!isProbablyEntrypoint(specifier, context.parentURL))
                    throw esmResolverError;
                try {
                    let cjsSpecifier = specifier;
                    // Attempt to convert from ESM file:// to CommonJS path
                    try {
                        if (specifier.startsWith('file://'))
                            cjsSpecifier = (0, url_1.fileURLToPath)(specifier);
                    }
                    catch { }
                    const resolution = (0, url_1.pathToFileURL)((0, module_1.createRequire)(process.cwd()).resolve(cjsSpecifier)).toString();
                    rememberIsProbablyEntrypoint.add(resolution);
                    rememberResolvedViaCommonjsFallback.add(resolution);
                    return { url: resolution, format: 'commonjs' };
                }
                catch (commonjsResolverError) {
                    throw esmResolverError;
                }
            }
        }
        return addShortCircuitFlag(async () => {
            const parsed = (0, url_1.parse)(specifier);
            const { pathname, protocol, hostname } = parsed;
            if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
                return entrypointFallback(defer);
            }
            if (protocol !== null && protocol !== 'file:') {
                return entrypointFallback(defer);
            }
            // Malformed file:// URL?  We should always see `null` or `''`
            if (hostname) {
                // TODO file://./foo sets `hostname` to `'.'`.  Perhaps we should special-case this.
                return entrypointFallback(defer);
            }
            // pathname is the path to be resolved
            return entrypointFallback(() => nodeResolveImplementation.defaultResolve(specifier, context, defaultResolve));
        });
    }
    // `load` from new loader hook API (See description at the top of this file)
    async function load(url, context, defaultLoad) {
        return addShortCircuitFlag(async () => {
            var _a;
            // If we get a format hint from resolve() on the context then use it
            // otherwise call the old getFormat() hook using node's old built-in defaultGetFormat() that ships with ts-node
            const format = (_a = context.format) !== null && _a !== void 0 ? _a : (await getFormat(url, context, nodeGetFormatImplementation.defaultGetFormat)).format;
            let source = undefined;
            if (format !== 'builtin' && format !== 'commonjs') {
                // Call the new defaultLoad() to get the source
                const { source: rawSource } = await defaultLoad(url, {
                    ...context,
                    format,
                }, defaultLoad);
                if (rawSource === undefined || rawSource === null) {
                    throw new Error(`Failed to load raw source: Format was '${format}' and url was '${url}''.`);
                }
                // Emulate node's built-in old defaultTransformSource() so we can re-use the old transformSource() hook
                const defaultTransformSource = async (source, _context, _defaultTransformSource) => ({ source });
                // Call the old hook
                const { source: transformedSource } = await transformSource(rawSource, { url, format }, defaultTransformSource);
                source = transformedSource;
            }
            return { format, source };
        });
    }
    async function getFormat(url, context, defaultGetFormat) {
        const defer = (overrideUrl = url) => defaultGetFormat(overrideUrl, context, defaultGetFormat);
        // See: https://github.com/nodejs/node/discussions/41711
        // nodejs will likely implement a similar fallback.  Till then, we can do our users a favor and fallback today.
        async function entrypointFallback(cb) {
            try {
                return await cb();
            }
            catch (getFormatError) {
                if (!rememberIsProbablyEntrypoint.has(url))
                    throw getFormatError;
                return { format: 'commonjs' };
            }
        }
        const parsed = (0, url_1.parse)(url);
        if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
            return entrypointFallback(defer);
        }
        const { pathname } = parsed;
        assert(pathname !== null, 'ESM getFormat() hook: URL should never have null pathname');
        const nativePath = (0, url_1.fileURLToPath)(url);
        let nodeSays;
        // If file has extension not understood by node, then ask node how it would treat the emitted extension.
        // E.g. .mts compiles to .mjs, so ask node how to classify an .mjs file.
        const ext = (0, path_1.extname)(nativePath);
        const tsNodeIgnored = tsNodeService.ignored(nativePath);
        const nodeEquivalentExt = extensions.nodeEquivalents.get(ext);
        if (nodeEquivalentExt && !tsNodeIgnored) {
            nodeSays = await entrypointFallback(() => defer((0, url_1.format)((0, url_1.pathToFileURL)(nativePath + nodeEquivalentExt))));
        }
        else {
            try {
                nodeSays = await entrypointFallback(defer);
            }
            catch (e) {
                if (e instanceof Error &&
                    tsNodeIgnored &&
                    extensions.nodeDoesNotUnderstand.includes(ext)) {
                    e.message +=
                        `\n\n` +
                            `Hint:\n` +
                            `ts-node is configured to ignore this file.\n` +
                            `If you want ts-node to handle this file, consider enabling the "skipIgnore" option or adjusting your "ignore" patterns.\n` +
                            `https://typestrong.org/ts-node/docs/scope\n`;
                }
                throw e;
            }
        }
        // For files compiled by ts-node that node believes are either CJS or ESM, check if we should override that classification
        if (!tsNodeService.ignored(nativePath) &&
            (nodeSays.format === 'commonjs' || nodeSays.format === 'module')) {
            const { moduleType } = tsNodeService.moduleTypeClassifier.classifyModuleByModuleTypeOverrides((0, util_1.normalizeSlashes)(nativePath));
            if (moduleType === 'cjs') {
                return { format: 'commonjs' };
            }
            else if (moduleType === 'esm') {
                return { format: 'module' };
            }
        }
        return nodeSays;
    }
    async function transformSource(source, context, defaultTransformSource) {
        if (source === null || source === undefined) {
            throw new Error('No source');
        }
        const defer = () => defaultTransformSource(source, context, defaultTransformSource);
        const sourceAsString = typeof source === 'string' ? source : source.toString('utf8');
        const { url } = context;
        const parsed = (0, url_1.parse)(url);
        if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
            return defer();
        }
        const nativePath = (0, url_1.fileURLToPath)(url);
        if (tsNodeService.ignored(nativePath)) {
            return defer();
        }
        const emittedJs = tsNodeService.compile(sourceAsString, nativePath);
        return { source: emittedJs };
    }
    return hooksAPI;
}
exports.createEsmHooks = createEsmHooks;
async function addShortCircuitFlag(fn) {
    const ret = await fn();
    // Not sure if this is necessary; being lazy.  Can revisit in the future.
    if (ret == null)
        return ret;
    return {
        ...ret,
        shortCircuit: true,
    };
}
//# sourceMappingURL=esm.js.map