hud-sdk/dist/esm/loader.mjs

Hud's Node SDK

import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";

;// external "url"
const external_url_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("url");
;// external "../cjs/instrument"
const instrument_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("../cjs/instrument");
;// external "../cjs/dto"
const dto_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("../cjs/dto");
;// external "../cjs/lib"
const lib_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("../cjs/lib");
;// ./src/modules/esmLoader/loader.mts




let hudAppPort;
let supportSourceMap;
let loadedUnsupportedTypescriptFormat = false;
const supportedNative = (0,lib_namespaceObject.isSupportedNative)();
const initialize = async ({ port }) => {
    hudAppPort = port;
    supportSourceMap = (0,lib_namespaceObject.shouldSupportSourceMap)();
    setTimeout(() => {
        try {
            lib_namespaceObject.instrument_logger.info("Getting tsconfig from esm loader");
            (0,lib_namespaceObject.getUserTsNodeConfig)(false);
        }
        catch (e) {
            lib_namespaceObject.instrument_logger.error("Error getting tsconfig from esm loader", {
                msg: e instanceof Error ? e.message : undefined,
                stack: e instanceof Error ? e.stack : undefined,
            });
        }
    }, lib_namespaceObject.hudConfig.tsNodeConfigTimeout);
};
const load = async (url, context, nextLoad) => {
    const originalLoadResult = await nextLoad(url, context);
    if (!supportedNative || !originalLoadResult.source) {
        return originalLoadResult;
    }
    try {
        if (originalLoadResult.format === dto_namespaceObject.Format.esm) {
            const modulePath = (0,external_url_namespaceObject.fileURLToPath)(url);
            lib_namespaceObject.instrument_logger.debug("Loading module", { modulePath });
            const patched = (0,instrument_namespaceObject.patch)(originalLoadResult.source?.toString(), modulePath, dto_namespaceObject.Format.esm, hudAppPort);
            originalLoadResult.source = patched.code;
            if (supportSourceMap && patched.map) {
                const map = (0,lib_namespaceObject.combineSourceMaps)(patched.map, modulePath);
                if (map) {
                    hudAppPort.postMessage({
                        key: "HudRetrieveFileCache",
                        filename: modulePath,
                        content: map,
                    });
                }
            }
        }
        else if (originalLoadResult.format === dto_namespaceObject.Format.moduleTypescript ||
            originalLoadResult.format === dto_namespaceObject.Format.commonjsTypescript) {
            if (!loadedUnsupportedTypescriptFormat) {
                loadedUnsupportedTypescriptFormat = true;
                lib_namespaceObject.instrument_logger.warn("Tried to load at least one unsupported typescript format");
            }
            const modulePath = (0,external_url_namespaceObject.fileURLToPath)(url);
            lib_namespaceObject.instrument_logger.debug("Loading unsupported format", {
                format: originalLoadResult.format,
                modulePath,
            });
        }
    }
    catch (e) {
        lib_namespaceObject.instrument_logger.error("Something went wrong in load hook", {
            msg: e instanceof Error ? e.message : undefined,
            stack: e instanceof Error ? e.stack : undefined,
        });
    }
    return originalLoadResult;
};

export { initialize, load };

//# sourceMappingURL=loader.mjs.map