@modern-js/utils/dist/cjs/cli/require.js

A Progressive React Framework for modern web development.

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, definition)=>{
        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
            enumerable: true,
            get: definition[key]
        });
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    cleanRequireCache: ()=>cleanRequireCache,
    compatibleRequire: ()=>compatibleRequire,
    dynamicImport: ()=>dynamicImport,
    loadFromProject: ()=>loadFromProject,
    requireExistModule: ()=>requireExistModule,
    tryResolve: ()=>tryResolve
});
const external_node_path_namespaceObject = require("node:path");
const external_node_url_namespaceObject = require("node:url");
const external_fs_js_namespaceObject = require("./fs.js");
async function importPath(path, options) {
    const modulePath = (0, external_node_path_namespaceObject.isAbsolute)(path) ? (0, external_node_url_namespaceObject.pathToFileURL)(path).href : path;
    if ('development' !== process.env.NODE_ENV) return await import(modulePath, options);
    {
        const timestamp = Date.now();
        return await import(`${modulePath}?t=${timestamp}`, options);
    }
}
async function compatibleRequireESM(path, interop = true) {
    if (path.endsWith('.json')) {
        const res = await importPath(path, {
            with: {
                type: 'json'
            }
        });
        return res.default;
    }
    const requiredModule = await importPath(path);
    return interop ? requiredModule.default : requiredModule;
}
async function compatibleRequireCJS(path, interop = true) {
    if (path.endsWith('.json')) return require(path);
    try {
        const requiredModule = require(path);
        return interop && requiredModule?.__esModule ? requiredModule.default : requiredModule;
    } catch (err) {
        if ('ERR_REQUIRE_ESM' === err.code) return await compatibleRequireESM(path, interop);
        throw err;
    }
}
async function compatibleRequire(path, interop = true) {
    return await compatibleRequireCJS(path, interop);
}
async function loadFromProject(moduleName, appDir) {
    let requiredModule;
    const paths = [
        appDir,
        process.cwd()
    ];
    try {
        const modulePath = tryResolve(moduleName, ...paths);
        requiredModule = require(modulePath);
        return requiredModule.default || requiredModule;
    } catch (error) {
        if ('MODULE_NOT_FOUND' === error.code) throw new Error(`Cannot find module ${moduleName}.`);
        throw error;
    }
}
const dynamicImport = new Function('modulePath', 'return import(modulePath)');
const requireExistModule = async (filename, opt)=>{
    const final = {
        extensions: [
            '.ts',
            '.js'
        ],
        interop: true,
        ...opt
    };
    const exist = (0, external_fs_js_namespaceObject.findExists)(final.extensions.map((ext)=>`${filename}${ext}`));
    if (!exist) return null;
    return compatibleRequire(exist, final.interop);
};
const cleanRequireCache = (filelist)=>{
    filelist.forEach((filepath)=>{
        if (require.cache) delete require.cache[filepath];
    });
};
const tryResolve = (name, ...resolvePath)=>{
    let filePath = '';
    try {
        filePath = require.resolve(name, {
            paths: resolvePath
        });
        delete require.cache[filePath];
    } catch (err) {
        if ('MODULE_NOT_FOUND' === err.code) throw new Error(`Can not find module ${name}.`);
        throw err;
    }
    return filePath;
};
exports.cleanRequireCache = __webpack_exports__.cleanRequireCache;
exports.compatibleRequire = __webpack_exports__.compatibleRequire;
exports.dynamicImport = __webpack_exports__.dynamicImport;
exports.loadFromProject = __webpack_exports__.loadFromProject;
exports.requireExistModule = __webpack_exports__.requireExistModule;
exports.tryResolve = __webpack_exports__.tryResolve;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "cleanRequireCache",
    "compatibleRequire",
    "dynamicImport",
    "loadFromProject",
    "requireExistModule",
    "tryResolve"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});