@modern-js/utils 2.12.1-alpha.3 → 2.13.0

package/dist/esm/watch.js

@@ -1,230 +0,0 @@
-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 { chokidar } from "./compiled";
-var WatchChangeType = {
-    ADD: "add",
-    UNLINK: "unlink",
-    CHANGE: "change"
-};
-var watch = function(watchDir, runTask) {
-    var ignored = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
-    var ready = false;
-    var watcher = chokidar.watch(watchDir, {
-        ignored: ignored
-    });
-    watcher.on("ready", function() {
-        return ready = true;
-    });
-    watcher.on("change", function() {
-        var _ref = _asyncToGenerator(function(filePath) {
-            var changedFilePath;
-            return __generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        changedFilePath = path.resolve(filePath);
-                        return [
-                            4,
-                            runTask({
-                                changedFilePath: changedFilePath,
-                                changeType: WatchChangeType.CHANGE
-                            })
-                        ];
-                    case 1:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function(filePath) {
-            return _ref.apply(this, arguments);
-        };
-    }());
-    watcher.on("add", function() {
-        var _ref = _asyncToGenerator(function(filePath) {
-            var changedFilePath;
-            return __generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        changedFilePath = path.resolve(filePath);
-                        if (!ready) return [
-                            3,
-                            2
-                        ];
-                        return [
-                            4,
-                            runTask({
-                                changedFilePath: changedFilePath,
-                                changeType: WatchChangeType.ADD
-                            })
-                        ];
-                    case 1:
-                        _state.sent();
-                        _state.label = 2;
-                    case 2:
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function(filePath) {
-            return _ref.apply(this, arguments);
-        };
-    }());
-    watcher.on("unlink", function() {
-        var _ref = _asyncToGenerator(function(filePath) {
-            var changedFilePath;
-            return __generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        changedFilePath = path.resolve(filePath);
-                        return [
-                            4,
-                            runTask({
-                                changedFilePath: changedFilePath,
-                                changeType: WatchChangeType.UNLINK
-                            })
-                        ];
-                    case 1:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function(filePath) {
-            return _ref.apply(this, arguments);
-        };
-    }());
-    watcher.on("error", function(err) {
-        throw err;
-    });
-    return watcher;
-};
-export { WatchChangeType, watch };

package/dist/esm-node/FileSizeReporter.js

@@ -1,133 +0,0 @@
-import fs from "fs";
-import path from "path";
-import {
-  chalk,
-  filesize,
-  stripAnsi,
-  gzipSize,
-  recursiveReaddir
-} from "./compiled";
-import { logger } from "./logger";
-function canReadAsset(asset) {
-  return /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[0-9a-f]+\.js/.test(asset);
-}
-function printFileSizesAfterBuild(webpackStats, previousSizeMap, buildFolder, maxBundleGzipSize, maxChunkGzipSize) {
-  var root = previousSizeMap.root;
-  var sizes = previousSizeMap.sizes;
-  var assets = (webpackStats.stats || [webpackStats]).map(
-    (stats) => stats.toJson({ all: false, assets: true }).assets.filter((asset) => canReadAsset(asset.name)).map((asset) => {
-      var fileContents = fs.readFileSync(path.join(root, asset.name));
-      var size = fileContents.length;
-      var gzippedSize = gzipSize.sync(fileContents);
-      var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
-      var sizeDifference = getDifferenceLabel(size, previousSize);
-      var gzipSizeDifference = getDifferenceLabel(
-        gzippedSize,
-        previousGzipSize
-      );
-      return {
-        folder: path.join(
-          path.basename(buildFolder),
-          path.dirname(asset.name)
-        ),
-        name: path.basename(asset.name),
-        gzippedSize,
-        sizeLabel: filesize(size) + (sizeDifference ? " (" + sizeDifference + ")" : ""),
-        gzipSizeLabel: filesize(gzippedSize) + (gzipSizeDifference ? " (" + gzipSizeDifference + ")" : "")
-      };
-    })
-  ).reduce((single, all) => all.concat(single), []);
-  assets.sort((a, b) => b.size - a.size);
-  var longestSizeLabelLength = Math.max.apply(
-    null,
-    assets.map((a) => stripAnsi(a.sizeLabel).length)
-  );
-  var longestFileNameLength = Math.max.apply(
-    null,
-    assets.map((a) => stripAnsi(a.folder + path.sep + a.name).length)
-  );
-  printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
-  var suggestBundleSplitting = false;
-  assets.forEach((asset) => {
-    var { folder, name, sizeLabel, gzipSizeLabel, gzippedSize } = asset;
-    var fileNameLength = stripAnsi(folder + path.sep + name).length;
-    var sizeLength = stripAnsi(sizeLabel).length;
-    if (sizeLength < longestSizeLabelLength) {
-      var rightPadding = " ".repeat(longestSizeLabelLength - sizeLength);
-      sizeLabel += rightPadding;
-    }
-    var fileNameLabel = chalk.dim(asset.folder + path.sep) + chalk.cyan(asset.name);
-    if (fileNameLength < longestFileNameLength) {
-      var rightPadding = " ".repeat(longestFileNameLength - fileNameLength);
-      fileNameLabel += rightPadding;
-    }
-    var isMainBundle = asset.name.indexOf("main.") === 0;
-    var maxRecommendedSize = isMainBundle ? maxBundleGzipSize : maxChunkGzipSize;
-    var isLarge = maxRecommendedSize && gzippedSize > maxRecommendedSize;
-    if (isLarge && path.extname(asset.name) === ".js") {
-      suggestBundleSplitting = true;
-    }
-    logger.log(
-      "  " + fileNameLabel + "    " + sizeLabel + "    " + (isLarge ? chalk.yellow(gzipSizeLabel) : gzipSizeLabel)
-    );
-  });
-  if (suggestBundleSplitting) {
-    logger.log();
-    logger.warn("The bundle size is significantly larger than recommended.");
-  }
-}
-function printFileSizesHeader(longestFileNameLength, longestSizeLabelLength) {
-  const longestLengths = [longestFileNameLength, longestSizeLabelLength];
-  const headerRow = ["File", "Size", "Gzipped"].reduce((prev, cur, index) => {
-    const length = longestLengths[index];
-    let curLabel = cur;
-    if (length) {
-      curLabel = cur.length < length ? cur + " ".repeat(length - cur.length) : cur;
-    }
-    return prev + curLabel + "    ";
-  }, "  ");
-  logger.log(chalk.bold(chalk.blue(headerRow)));
-}
-function removeFileNameHash(buildFolder, fileName) {
-  return fileName.replace(buildFolder, "").replace(/\\/g, "/").replace(
-    /\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/,
-    (match, p1, p2, p3, p4) => p1 + p4
-  );
-}
-function getDifferenceLabel(currentSize, previousSize) {
-  var FIFTY_KILOBYTES = 1024 * 50;
-  var difference = currentSize - previousSize;
-  var fileSize = !Number.isNaN(difference) ? filesize(difference) : 0;
-  if (difference >= FIFTY_KILOBYTES) {
-    return chalk.red("+" + fileSize);
-  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
-    return chalk.yellow("+" + fileSize);
-  } else if (difference < 0) {
-    return chalk.green(fileSize);
-  } else {
-    return "";
-  }
-}
-function measureFileSizesBeforeBuild(buildFolder) {
-  return new Promise((resolve) => {
-    recursiveReaddir(buildFolder, (err, fileNames) => {
-      var sizes;
-      if (!err && fileNames) {
-        sizes = fileNames.filter(canReadAsset).reduce((memo, fileName) => {
-          var contents = fs.readFileSync(fileName);
-          var key = removeFileNameHash(buildFolder, fileName);
-          memo[key] = [contents.length, gzipSize.sync(contents)];
-          return memo;
-        }, {});
-      }
-      resolve({
-        root: buildFolder,
-        sizes: sizes || {}
-      });
-    });
-  });
-}
-export {
-  measureFileSizesBeforeBuild,
-  printFileSizesAfterBuild
-};

package/dist/esm-node/alias.js

@@ -1,61 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { chalk } from "./compiled";
-import { readTsConfigByFile } from "./readTsConfig";
-import { applyOptionsChain } from "./applyOptionsChain";
-const validAlias = (modernConfig, { tsconfigPath }) => {
-  const {
-    source: { alias }
-  } = modernConfig;
-  if (!alias) {
-    return null;
-  }
-  const isTsProject = fs.existsSync(tsconfigPath);
-  if (!isTsProject) {
-    return null;
-  }
-  const userAlias = getUserAlias(alias);
-  if (Object.keys(userAlias).length > 0) {
-    return chalk.red(
-      'Note: Please use `compilerOptions.paths` in "tsconfig.json" file replace `source.alias` config in "modern.config.js/ts" when project is typescript'
-    );
-  }
-  return null;
-};
-const mergeAlias = (alias) => applyOptionsChain({}, alias);
-const getAliasConfig = (aliasOption, option) => {
-  var _a, _b;
-  const isTsProject = fs.existsSync(option.tsconfigPath);
-  const alias = mergeAlias(aliasOption);
-  if (!isTsProject) {
-    return {
-      absoluteBaseUrl: option.appDirectory,
-      paths: alias,
-      isTsPath: false,
-      isTsProject
-    };
-  }
-  const tsconfig = readTsConfigByFile(option.tsconfigPath);
-  const baseUrl = (_a = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _a.baseUrl;
-  return {
-    absoluteBaseUrl: baseUrl ? path.join(option.appDirectory, baseUrl) : option.appDirectory,
-    paths: {
-      ...alias,
-      ...(_b = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _b.paths
-    },
-    isTsPath: true,
-    isTsProject
-  };
-};
-const getUserAlias = (alias = {}) => Object.keys(alias).reduce((o, k) => {
-  if (Array.isArray(alias[k])) {
-    o[k] = alias[k];
-  }
-  return o;
-}, {});
-export {
-  getAliasConfig,
-  getUserAlias,
-  mergeAlias,
-  validAlias
-};

package/dist/esm-node/analyzeProject.js

@@ -1,17 +0,0 @@
-import * as path from "path";
-import { getArgv } from "./commands";
-import { fs, minimist } from "./compiled";
-const isApiOnly = async (appDirectory, entryDir) => {
-  const srcDir = path.join(appDirectory, entryDir != null ? entryDir : "src");
-  const existSrc = await fs.pathExists(srcDir);
-  const options = minimist(getArgv());
-  return !existSrc || Boolean(options["api-only"]);
-};
-const isWebOnly = async () => {
-  const options = minimist(getArgv());
-  return Boolean(options["web-only"]);
-};
-export {
-  isApiOnly,
-  isWebOnly
-};

package/dist/esm-node/applyOptionsChain.js

@@ -1,35 +0,0 @@
-import { isFunction, logger, isPlainObject } from "./index";
-function applyOptionsChain(defaults, options, utils, mergeFn = Object.assign) {
-  if (!options) {
-    return defaults;
-  }
-  if (isPlainObject(options)) {
-    return mergeFn(defaults, options);
-  } else if (isFunction(options)) {
-    const ret = options(defaults, utils);
-    if (ret) {
-      if (!isPlainObject(ret)) {
-        logger.warn(
-          `${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`
-        );
-      }
-      return ret;
-    }
-  } else if (Array.isArray(options)) {
-    return options.reduce(
-      (memo, cur) => applyOptionsChain(memo, cur, utils, mergeFn),
-      defaults
-    );
-  } else {
-    throw new Error(
-      `applyOptionsChain error:
-default options is: ${JSON.stringify(
-        defaults
-      )}`
-    );
-  }
-  return defaults;
-}
-export {
-  applyOptionsChain
-};

package/dist/esm-node/babel.js

@@ -1,105 +0,0 @@
-import { isAbsolute, sep } from "path";
-import { applyOptionsChain } from "./applyOptionsChain";
-import { ensureArray } from "./ensureArray";
-import { normalizeToPosixPath } from "./path";
-const formatPath = (originPath) => {
-  if (isAbsolute(originPath)) {
-    return originPath.split(sep).join("/");
-  }
-  return originPath;
-};
-const getPluginItemName = (item) => {
-  if (typeof item === "string") {
-    return formatPath(item);
-  }
-  if (Array.isArray(item) && typeof item[0] === "string") {
-    return formatPath(item[0]);
-  }
-  return null;
-};
-const addPlugins = (plugins, config) => {
-  if (config.plugins) {
-    config.plugins.push(...plugins);
-  } else {
-    config.plugins = plugins;
-  }
-};
-const addPresets = (presets, config) => {
-  if (config.presets) {
-    config.presets.push(...presets);
-  } else {
-    config.presets = presets;
-  }
-};
-const removePlugins = (plugins, config) => {
-  if (!config.plugins) {
-    return;
-  }
-  const removeList = ensureArray(plugins);
-  config.plugins = config.plugins.filter((item) => {
-    const name = getPluginItemName(item);
-    if (name) {
-      return !removeList.find((removeItem) => name.includes(removeItem));
-    }
-    return true;
-  });
-};
-const removePresets = (presets, config) => {
-  if (!config.presets) {
-    return;
-  }
-  const removeList = ensureArray(presets);
-  config.presets = config.presets.filter((item) => {
-    const name = getPluginItemName(item);
-    if (name) {
-      return !removeList.find((removeItem) => name.includes(removeItem));
-    }
-    return true;
-  });
-};
-const modifyPresetOptions = (presetName, options, presets = []) => {
-  presets.forEach((preset, index) => {
-    if (Array.isArray(preset)) {
-      if (typeof preset[0] === "string" && normalizeToPosixPath(preset[0]).includes(presetName)) {
-        preset[1] = {
-          ...preset[1] || {},
-          ...options
-          // `options` is specific to different presets
-        };
-      }
-    } else if (typeof preset === "string" && normalizeToPosixPath(preset).includes(presetName)) {
-      presets[index] = [preset, options];
-    }
-  });
-};
-const getBabelUtils = (config) => {
-  const noop = () => {
-  };
-  return {
-    addPlugins: (plugins) => addPlugins(plugins, config),
-    addPresets: (presets) => addPresets(presets, config),
-    removePlugins: (plugins) => removePlugins(plugins, config),
-    removePresets: (presets) => removePresets(presets, config),
-    // `addIncludes` and `addExcludes` are noop functions by default,
-    // It can be overridden by `extraBabelUtils`.
-    addIncludes: noop,
-    addExcludes: noop,
-    // Compat `presetEnvOptions` and `presetReactOptions` in Eden.
-    modifyPresetEnvOptions: (options) => modifyPresetOptions("@babel/preset-env", options, config.presets || []),
-    modifyPresetReactOptions: (options) => modifyPresetOptions("@babel/preset-react", options, config.presets || [])
-  };
-};
-const applyUserBabelConfig = (defaultOptions, userBabelConfig, extraBabelUtils) => {
-  if (userBabelConfig) {
-    const babelUtils = {
-      ...getBabelUtils(defaultOptions),
-      ...extraBabelUtils
-    };
-    return applyOptionsChain(defaultOptions, userBabelConfig || {}, babelUtils);
-  }
-  return defaultOptions;
-};
-export {
-  applyUserBabelConfig,
-  getBabelUtils
-};