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

package/dist/esm/watch.js

@@ -0,0 +1,230 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,105 @@
+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
+};