@modern-js/utils 2.11.0 → 2.12.1-alpha.0

package/dist/esm/getPackageManager.js

@@ -0,0 +1,187 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import os from "os";
+import path from "path";
+import { fs } from "./compiled";
+import { canUsePnpm, canUseYarn } from "./nodeEnv";
+var MAX_TIMES = 5;
+function getPackageManager() {
+    return _getPackageManager.apply(this, arguments);
+}
+function _getPackageManager() {
+    _getPackageManager = _asyncToGenerator(function() {
+        var cwd, appDirectory, times;
+        var _arguments = arguments;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    cwd = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : process.cwd();
+                    appDirectory = cwd;
+                    times = 0;
+                    while(os.homedir() !== appDirectory && times < MAX_TIMES){
+                        times++;
+                        if (fs.existsSync(path.resolve(appDirectory, "pnpm-lock.yaml"))) {
+                            return "pnpm";
+                        }
+                        if (fs.existsSync(path.resolve(appDirectory, "yarn.lock"))) {
+                            return "yarn";
+                        }
+                        if (fs.existsSync(path.resolve(appDirectory, "package-lock.json"))) {
+                            return "npm";
+                        }
+                        appDirectory = path.join(appDirectory, "..");
+                    }
+                    return [
+                        4,
+                        canUsePnpm()
+                    ];
+                case 1:
+                    if (_state.sent()) {
+                        return [
+                            2,
+                            "pnpm"
+                        ];
+                    }
+                    return [
+                        4,
+                        canUseYarn()
+                    ];
+                case 2:
+                    if (_state.sent()) {
+                        return [
+                            2,
+                            "yarn"
+                        ];
+                    }
+                    return [
+                        2,
+                        "npm"
+                    ];
+            }
+        });
+    });
+    return _getPackageManager.apply(this, arguments);
+}
+export { getPackageManager };

package/dist/esm/getPort.js

@@ -0,0 +1,215 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import net from "net";
+import { chalk } from "./compiled";
+import { logger } from "./logger";
+var getPort = function() {
+    var _ref = _asyncToGenerator(function(port) {
+        var _ref, _ref_tryLimits, tryLimits, _ref_strictPort, strictPort, original, found, attempts, e;
+        var _arguments = arguments;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _ref = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {}, _ref_tryLimits = _ref.tryLimits, tryLimits = _ref_tryLimits === void 0 ? 20 : _ref_tryLimits, _ref_strictPort = _ref.strictPort, strictPort = _ref_strictPort === void 0 ? false : _ref_strictPort;
+                    if (typeof port === "string") {
+                        port = parseInt(port, 10);
+                    }
+                    if (strictPort) {
+                        tryLimits = 1;
+                    }
+                    original = port;
+                    found = false;
+                    attempts = 0;
+                    _state.label = 1;
+                case 1:
+                    if (!(!found && attempts <= tryLimits)) return [
+                        3,
+                        6
+                    ];
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            var server = net.createServer();
+                            server.unref();
+                            server.on("error", reject);
+                            server.listen({
+                                port: port,
+                                host: "0.0.0.0"
+                            }, function() {
+                                found = true;
+                                server.close(resolve);
+                            });
+                        })
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    e = _state.sent();
+                    if (e.code !== "EADDRINUSE") {
+                        throw e;
+                    }
+                    port++;
+                    attempts++;
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        3,
+                        1
+                    ];
+                case 6:
+                    if (port !== original) {
+                        if (strictPort) {
+                            throw new Error('Port "'.concat(original, '" is occupied, please choose another one.'));
+                        } else {
+                            logger.info("Something is already running on port ".concat(original, ". ").concat(chalk.yellow("Use port ".concat(port, " instead."))));
+                        }
+                    }
+                    return [
+                        2,
+                        port
+                    ];
+            }
+        });
+    });
+    return function getPort(port) {
+        return _ref.apply(this, arguments);
+    };
+}();
+export { getPort };

package/dist/esm/getServerConfig.js

@@ -0,0 +1,145 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import * as path from "path";
+import { CONFIG_FILE_EXTENSIONS } from "./constants";
+import { findExists } from "./findExists";
+var getServerConfig = function() {
+    var _ref = _asyncToGenerator(function(appDirectory, configFile) {
+        var configFilePath;
+        return __generator(this, function(_state) {
+            configFilePath = findExists(CONFIG_FILE_EXTENSIONS.map(function(extension) {
+                return path.resolve(appDirectory, "".concat(configFile).concat(extension));
+            }));
+            return [
+                2,
+                configFilePath
+            ];
+        });
+    });
+    return function getServerConfig(appDirectory, configFile) {
+        return _ref.apply(this, arguments);
+    };
+}();
+export { getServerConfig };

package/dist/esm/getTargetDir.js

@@ -0,0 +1,6 @@
+import * as path from "path";
+var getTargetDir = function(from, baseDir, targetBaseDir) {
+    var relativePath = path.relative(baseDir, from);
+    return path.resolve(targetBaseDir, relativePath);
+};
+export { getTargetDir };

package/dist/esm/import.js

@@ -0,0 +1,8 @@
+var lazy = function(moduleName, requireFn) {
+    var importLazyLocal = require("../compiled/import-lazy")(requireFn);
+    return importLazyLocal(moduleName);
+};
+var Import = {
+    lazy: lazy
+};
+export { Import, lazy as lazyImport };

package/dist/esm/index.js

@@ -0,0 +1,44 @@
+export * from "./compiled";
+export * from "./commands";
+export * from "./FileSizeReporter";
+export * from "./printBuildError";
+export * from "./debug";
+export * from "./findExists";
+export * from "./is";
+export * from "./compatRequire";
+export * from "./logger";
+export * from "./constants";
+export * from "./ensureArray";
+export * from "./ensureAbsolutePath";
+export * from "./clearConsole";
+export * from "./applyOptionsChain";
+export * from "./getBrowserslist";
+export * from "./removeSlash";
+export * from "./getEntryOptions";
+export * from "./getPort";
+export * from "./monorepo";
+export * from "./getPackageManager";
+export * from "./runtimeExports";
+export * from "./readTsConfig";
+export * from "./path";
+export * from "./pathSerializer";
+export * from "./generateMetaTags";
+export * from "./prettyInstructions";
+export * from "./alias";
+export * from "./import";
+export * from "./watch";
+export * from "./nodeEnv";
+export * from "./wait";
+export * from "./emptyDir";
+export * from "./getServerConfig";
+export * from "./resolve";
+export * from "./analyzeProject";
+export * from "./chainId";
+export * from "./version";
+export * from "./plugin";
+export * from "./routes";
+export * from "./testUtils";
+export * from "./getCoreJsVersion";
+export * from "./react";
+export * from "./getTargetDir";
+export * from "./babel";

package/dist/esm/is/index.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+import { createDebugger } from "../debug";
+import { isDev } from "./nodeEnv";
+var debug = createDebugger("judge-depExists");
+var isDepExists = function(appDirectory, name) {
+    var pkgPath = path.resolve(appDirectory, "./package.json");
+    if (!fs.existsSync(pkgPath)) {
+        debug("can't find package.json under: %s", appDirectory);
+        return false;
+    }
+    var json = require(pkgPath);
+    var _json_dependencies = json.dependencies, dependencies = _json_dependencies === void 0 ? {} : _json_dependencies, _json_devDependencies = json.devDependencies, devDependencies = _json_devDependencies === void 0 ? {} : _json_devDependencies;
+    return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
+};
+var isTypescript = function(root) {
+    return fs.existsSync(path.resolve(root, "./tsconfig.json"));
+};
+var isEmpty = function(o) {
+    return Object.entries(o).length === 0 && o.constructor === Object;
+};
+var isSSR = function(config) {
+    var server = config.server;
+    if (server === null || server === void 0 ? void 0 : server.ssr) {
+        return true;
+    }
+    if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && !isEmpty(server.ssrByEntries)) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.keys(server.ssrByEntries)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                if (server.ssrByEntries[name]) {
+                    return true;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return false;
+};
+var isUseSSRBundle = function(config) {
+    var output = config.output;
+    if (output === null || output === void 0 ? void 0 : output.ssg) {
+        return true;
+    }
+    return isSSR(config);
+};
+var isServiceWorker = function(config) {
+    var output = config.output, server = config.server;
+    if ((server === null || server === void 0 ? void 0 : server.worker) && ((output === null || output === void 0 ? void 0 : output.ssg) || isSSR(config))) {
+        return true;
+    }
+    return false;
+};
+var isFastRefresh = function() {
+    return isDev() && process.env.FAST_REFRESH !== "false";
+};
+var isRouterV5 = function(config) {
+    var _config_runtime, _config_runtime1, _config_runtime_router;
+    return typeof ((_config_runtime = config.runtime) === null || _config_runtime === void 0 ? void 0 : _config_runtime.router) !== "boolean" && (config === null || config === void 0 ? void 0 : (_config_runtime1 = config.runtime) === null || _config_runtime1 === void 0 ? void 0 : (_config_runtime_router = _config_runtime1.router) === null || _config_runtime_router === void 0 ? void 0 : _config_runtime_router.mode) === "react-router-5";
+};
+var isSSGEntry = function(config, entryName, entrypoints) {
+    var ssgConfig = config.output.ssg;
+    var useSSG = isSingleEntry(entrypoints) ? Boolean(ssgConfig) : ssgConfig === true || typeof (ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[0]) === "function" || Boolean(ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[entryName]);
+    return useSSG;
+};
+var isSingleEntry = function(entrypoints) {
+    return entrypoints.length === 1 && entrypoints[0].entryName === "main";
+};
+export * from "./nodeEnv";
+export * from "./platform";
+export * from "./type";
+export { isDepExists, isEmpty, isFastRefresh, isRouterV5, isSSGEntry, isSSR, isServiceWorker, isSingleEntry, isTypescript, isUseSSRBundle };