"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.load = load;
exports.loadWithData = loadWithData;
exports.loadWithDataFromManifest = loadWithDataFromManifest;
exports.isPathModule = isPathModule;
const getPackageType = require('get-package-type');
const node_fs_1 = require("node:fs");
const node_path_1 = require("node:path");
const node_url_1 = require("node:url");
const ts_path_1 = require("./config/ts-path");
const module_load_1 = require("./errors/errors/module-load");
const fs_1 = require("./util/fs");
/**
 * Defines file extension resolution when source files do not have an extension.
 */
const SUPPORTED_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts', '.tsx', '.jsx'];
const isPlugin = (config) => config.type !== undefined;
function handleError(error, isESM, path) {
    if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
        throw new module_load_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${path}: ${error.message}`);
    }
    throw error;
}
/**
 * Loads and returns a module.
 *
 * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
 * a bare require to load as CJS. Also loads '.mjs' files as ESM.
 *
 * Uses dynamic import to load ESM source or require for CommonJS.
 *
 * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
 * provides a consistent stack trace and info.
 *
 * @param {IConfig|IPlugin} config - Oclif config or plugin config.
 * @param {string} modulePath - NPM module name or file path to load.
 *
 * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
 */
async function load(config, modulePath) {
    let filePath;
    let isESM;
    try {
        ;
        ({ filePath, isESM } = await resolvePath(config, modulePath));
        return (isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath));
    }
    catch (error) {
        handleError(error, isESM, filePath ?? modulePath);
    }
}
/**
 * Loads a module and returns an object with the module and data about the module.
 *
 * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
 * a bare require to load as CJS. Also loads '.mjs' files as ESM.
 *
 * Uses dynamic import to load ESM source or require for CommonJS.
 *
 * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
 * provides a consistent stack trace and info.
 *
 * @param {IConfig|IPlugin} config - Oclif config or plugin config.
 * @param {string} modulePath - NPM module name or file path to load.
 *
 * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
 *                                                                   file path and whether the module is ESM.
 */
async function loadWithData(config, modulePath) {
    let filePath;
    let isESM;
    try {
        ;
        ({ filePath, isESM } = await resolvePath(config, modulePath));
        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
        return { filePath, isESM, module };
    }
    catch (error) {
        handleError(error, isESM, filePath ?? modulePath);
    }
}
/**
 * Loads a module and returns an object with the module and data about the module.
 *
 * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
 * or require (isESM = false | undefined) should be used.
 *
 * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
 * provides a consistent stack trace and info.
 *
 * @param {Command.Cached} cached - Cached command data from plugin manifest.
 * @param {string} modulePath - NPM module name or file path to load.
 *
 * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
 *                                                                   file path and whether the module is ESM.
 */
async function loadWithDataFromManifest(cached, modulePath) {
    const { id, isESM, relativePath } = cached;
    if (!relativePath) {
        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have a relative path`);
    }
    if (isESM === undefined) {
        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have the isESM property set`);
    }
    const filePath = (0, node_path_1.join)(modulePath, relativePath.join(node_path_1.sep));
    try {
        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
        return { filePath, isESM, module };
    }
    catch (error) {
        handleError(error, isESM, filePath ?? modulePath);
    }
}
/**
 * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
 * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
 *
 * @param {string} filePath - File path to test.
 *
 * @returns {boolean} The modulePath is an ES Module.
 * @see https://www.npmjs.com/package/get-package-type
 */
function isPathModule(filePath) {
    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
    switch (extension) {
        case '.js':
        case '.jsx':
        case '.ts':
        case '.tsx': {
            return getPackageType.sync(filePath) === 'module';
        }
        case '.mjs':
        case '.mts': {
            return true;
        }
        default: {
            return false;
        }
    }
}
/**
 * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
 * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
 * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
 * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
 *
 * @param {IConfig|IPlugin} config - Oclif config or plugin config.
 * @param {string} modulePath - File path to load.
 *
 * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
 */
async function resolvePath(config, modulePath) {
    let isESM;
    let filePath;
    try {
        filePath = require.resolve(modulePath);
        isESM = isPathModule(filePath);
    }
    catch {
        filePath =
            (isPlugin(config) ? await (0, ts_path_1.tsPath)(config.root, modulePath, config) : await (0, ts_path_1.tsPath)(config.root, modulePath)) ??
                modulePath;
        let fileExists = false;
        let isDirectory = false;
        if ((0, fs_1.existsSync)(filePath)) {
            fileExists = true;
            try {
                if ((0, node_fs_1.lstatSync)(filePath)?.isDirectory?.()) {
                    fileExists = false;
                    isDirectory = true;
                }
            }
            catch { }
        }
        if (!fileExists) {
            // Try all supported extensions.
            let foundPath = findFile(filePath);
            if (!foundPath && isDirectory) {
                // Since filePath is a directory, try looking for index file.
                foundPath = findFile((0, node_path_1.join)(filePath, 'index'));
            }
            if (foundPath) {
                filePath = foundPath;
            }
        }
        isESM = isPathModule(filePath);
    }
    return { filePath, isESM };
}
/**
 * Try adding the different extensions from `s_EXTENSIONS` to find the file.
 *
 * @param {string} filePath - File path to load.
 *
 * @returns {string | null} Modified file path including extension or null if file is not found.
 */
function findFile(filePath) {
    for (const extension of SUPPORTED_EXTENSIONS) {
        const testPath = `${filePath}${extension}`;
        if ((0, fs_1.existsSync)(testPath)) {
            return testPath;
        }
    }
    return null;
}
