@modern-js/utils 1.3.4 → 1.3.7-alpha.prebundle.0

package/dist/src/FileSizeReporter.js

@@ -0,0 +1,152 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+// Modified by Chao Xu (xuchaobei)
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFileSizesAfterBuild = exports.measureFileSizesBeforeBuild = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const recursive_readdir_1 = __importDefault(require("recursive-readdir"));
+const logger_1 = require("./logger");
+function canReadAsset(asset) {
+    return (/\.(js|css)$/.test(asset) &&
+        !/service-worker\.js/.test(asset) &&
+        !/precache-manifest\.[0-9a-f]+\.js/.test(asset));
+}
+// Prints a detailed summary of build files.
+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_1.default.readFileSync(path_1.default.join(root, asset.name));
+        var size = fileContents.length;
+        var gzippedSize = compiled_1.gzipSize.sync(fileContents);
+        var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
+        var sizeDifference = getDifferenceLabel(size, previousSize);
+        var gzipSizeDifference = getDifferenceLabel(gzippedSize, previousGzipSize);
+        return {
+            folder: path_1.default.join(path_1.default.basename(buildFolder), path_1.default.dirname(asset.name)),
+            name: path_1.default.basename(asset.name),
+            gzippedSize: gzippedSize,
+            sizeLabel: (0, compiled_1.filesize)(size) +
+                (sizeDifference ? ' (' + sizeDifference + ')' : ''),
+            gzipSizeLabel: (0, compiled_1.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) => (0, compiled_1.stripAnsi)(a.sizeLabel).length));
+    var longestFileNameLength = Math.max.apply(null, assets.map((a) => (0, compiled_1.stripAnsi)(a.folder + path_1.default.sep + a.name).length));
+    printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
+    var suggestBundleSplitting = false;
+    assets.forEach((asset) => {
+        var { folder, name, sizeLabel, gzipSizeLabel, gzippedSize } = asset;
+        var fileNameLength = (0, compiled_1.stripAnsi)(folder + path_1.default.sep + name).length;
+        var sizeLength = (0, compiled_1.stripAnsi)(sizeLabel).length;
+        if (sizeLength < longestSizeLabelLength) {
+            var rightPadding = ' '.repeat(longestSizeLabelLength - sizeLength);
+            sizeLabel += rightPadding;
+        }
+        var fileNameLabel = compiled_1.chalk.dim(asset.folder + path_1.default.sep) + compiled_1.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_1.default.extname(asset.name) === '.js') {
+            suggestBundleSplitting = true;
+        }
+        logger_1.logger.log('  ' +
+            fileNameLabel +
+            '    ' +
+            sizeLabel +
+            '    ' +
+            (isLarge ? compiled_1.chalk.yellow(gzipSizeLabel) : gzipSizeLabel));
+    });
+    if (suggestBundleSplitting) {
+        logger_1.logger.log();
+        logger_1.logger.warn('The bundle size is significantly larger than recommended.');
+    }
+}
+exports.printFileSizesAfterBuild = printFileSizesAfterBuild;
+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_1.logger.log(compiled_1.chalk.bold(compiled_1.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);
+}
+// Input: 1024, 2048
+// Output: "(+1 KB)"
+function getDifferenceLabel(currentSize, previousSize) {
+    var FIFTY_KILOBYTES = 1024 * 50;
+    var difference = currentSize - previousSize;
+    var fileSize = !Number.isNaN(difference) ? (0, compiled_1.filesize)(difference) : 0;
+    if (difference >= FIFTY_KILOBYTES) {
+        return compiled_1.chalk.red('+' + fileSize);
+    }
+    else if (difference < FIFTY_KILOBYTES && difference > 0) {
+        return compiled_1.chalk.yellow('+' + fileSize);
+    }
+    else if (difference < 0) {
+        return compiled_1.chalk.green(fileSize);
+    }
+    else {
+        return '';
+    }
+}
+function measureFileSizesBeforeBuild(buildFolder) {
+    return new Promise(resolve => {
+        (0, recursive_readdir_1.default)(buildFolder, (err, fileNames) => {
+            var sizes;
+            if (!err && fileNames) {
+                sizes = fileNames
+                    .filter(canReadAsset)
+                    .reduce((memo, fileName) => {
+                    var contents = fs_1.default.readFileSync(fileName);
+                    var key = removeFileNameHash(buildFolder, fileName);
+                    // save both the original size and gzip size
+                    memo[key] = [contents.length, compiled_1.gzipSize.sync(contents)];
+                    return memo;
+                }, {});
+            }
+            resolve({
+                root: buildFolder,
+                sizes: sizes || {},
+            });
+        });
+    });
+}
+exports.measureFileSizesBeforeBuild = measureFileSizesBeforeBuild;

package/dist/src/alias.d.ts

@@ -0,0 +1,21 @@
+declare type AliasOption = Record<string, string> | ((aliases: Record<string, string>) => Record<string, unknown>) | Record<string, string> | undefined;
+interface NormalizedConfig {
+    source: {
+        alias?: AliasOption | Array<AliasOption>;
+    };
+}
+interface IAliasConfig {
+    absoluteBaseUrl: string;
+    paths?: Record<string, string | string[]>;
+    isTsPath?: boolean;
+    isTsProject?: boolean;
+}
+export declare const validAlias: <T extends NormalizedConfig>(modernConfig: T, { tsconfigPath }: {
+    tsconfigPath: string;
+}) => string | null;
+export declare const getAlias: (aliasOption: AliasOption | Array<AliasOption>, option: {
+    appDirectory: string;
+    tsconfigPath: string;
+}) => IAliasConfig;
+export declare const getUserAlias: (alias?: Record<string, string | string[]>) => Record<string, string | string[]>;
+export {};

package/dist/src/alias.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserAlias = exports.getAlias = exports.validAlias = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const readTsConfig_1 = require("./readTsConfig");
+const applyOptionsChain_1 = require("./applyOptionsChain");
+const validAlias = (modernConfig, { tsconfigPath }) => {
+    const { source: { alias }, } = modernConfig;
+    if (!alias) {
+        return null;
+    }
+    const isTsProject = fs_1.default.existsSync(tsconfigPath);
+    if (!isTsProject) {
+        return null;
+    }
+    const userAlias = (0, exports.getUserAlias)(alias);
+    if (Object.keys(userAlias).length > 0) {
+        return compiled_1.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;
+};
+exports.validAlias = validAlias;
+const getAlias = (aliasOption, option) => {
+    var _a, _b;
+    const isTsProject = fs_1.default.existsSync(option.tsconfigPath);
+    let aliasConfig;
+    if (!isTsProject) {
+        aliasConfig = {
+            absoluteBaseUrl: option.appDirectory,
+            paths: (0, applyOptionsChain_1.applyOptionsChain)({ '@': ['./src'] }, aliasOption),
+            isTsPath: false,
+            isTsProject,
+        };
+    }
+    else {
+        const tsconfig = (0, readTsConfig_1.readTsConfigByFile)(option.tsconfigPath);
+        const baseUrl = (_a = tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl;
+        aliasConfig = {
+            absoluteBaseUrl: baseUrl
+                ? path_1.default.join(option.appDirectory, baseUrl)
+                : option.appDirectory,
+            paths: Object.assign(Object.assign({}, (aliasOption || {})), (_b = tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.paths),
+            isTsPath: true,
+            isTsProject,
+        };
+    }
+    return aliasConfig;
+};
+exports.getAlias = getAlias;
+// filter invalid ts paths that are not array
+const getUserAlias = (alias = {}) => Object.keys(alias).reduce((o, k) => {
+    if (Array.isArray(alias[k])) {
+        o[k] = alias[k];
+    }
+    return o;
+}, {});
+exports.getUserAlias = getUserAlias;

package/dist/src/applyOptionsChain.d.ts

@@ -0,0 +1,6 @@
+export declare const applyOptionsChain: <T, U>(defaults: T, options?: T | (T | ((config: T, utils?: U | undefined) => void | T))[] | ((config: T, utils?: U | undefined) => void | T) | undefined, utils?: U | undefined, mergeFn?: {
+    <T_1, U_1>(target: T_1, source: U_1): T_1 & U_1;
+    <T_2, U_2, V>(target: T_2, source1: U_2, source2: V): T_2 & U_2 & V;
+    <T_3, U_3, V_1, W>(target: T_3, source1: U_3, source2: V_1, source3: W): T_3 & U_3 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}) => T;

package/dist/src/applyOptionsChain.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOptionsChain = void 0;
+// eslint-disable-next-line import/no-useless-path-segments
+const index_1 = require("./index");
+const applyOptionsChain = (defaults, options, utils, mergeFn = Object.assign) => {
+    if (!options) {
+        return defaults;
+    }
+    if ((0, index_1.isPlainObject)(options)) {
+        return mergeFn(defaults, options);
+    }
+    else if ((0, index_1.isFunction)(options)) {
+        const ret = options(defaults, utils);
+        if (ret) {
+            if (!(0, index_1.isPlainObject)(ret)) {
+                index_1.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) => (0, exports.applyOptionsChain)(memo, cur, utils, mergeFn), defaults);
+    }
+    else {
+        throw new Error(`applyOptionsChain error:\ndefault options is: ${JSON.stringify(defaults)}`);
+    }
+    return defaults;
+};
+exports.applyOptionsChain = applyOptionsChain;

package/dist/src/clearConsole.d.ts

@@ -0,0 +1 @@
+export declare const clearConsole: () => void;

package/dist/src/clearConsole.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearConsole = void 0;
+const clearConsole = () => {
+    if (process.stdout.isTTY && !process.env.DEBUG) {
+        process.stdout.write('\x1B[H\x1B[2J');
+    }
+};
+exports.clearConsole = clearConsole;

package/dist/src/compatRequire.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Require function compatible with esm and cjs module.
+ * @param filePath - File to required.
+ * @returns module export object.
+ */
+export declare const compatRequire: (filePath: string) => any;
+export declare const requireExistModule: (filename: string, extensions?: string[]) => any;
+export declare const cleanRequireCache: (filelist: string[]) => void;

package/dist/src/compatRequire.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanRequireCache = exports.requireExistModule = exports.compatRequire = void 0;
+const findExists_1 = require("./findExists");
+/**
+ * Require function compatible with esm and cjs module.
+ * @param filePath - File to required.
+ * @returns module export object.
+ */
+const compatRequire = (filePath) => {
+    const mod = require(filePath);
+    return (mod === null || mod === void 0 ? void 0 : mod.__esModule) ? mod.default : mod;
+};
+exports.compatRequire = compatRequire;
+const requireExistModule = (filename, extensions = ['.ts', '.js']) => {
+    const exist = (0, findExists_1.findExists)(extensions.map(ext => `${filename}${ext}`));
+    if (!exist) {
+        return null;
+    }
+    return (0, exports.compatRequire)(exist);
+};
+exports.requireExistModule = requireExistModule;
+const cleanRequireCache = (filelist) => {
+    filelist.forEach(filepath => {
+        delete require.cache[filepath];
+    });
+};
+exports.cleanRequireCache = cleanRequireCache;

package/dist/src/compiled.d.ts

@@ -0,0 +1,7 @@
+import chalk from '../compiled/chalk';
+import upath from '../compiled/upath';
+import pkgUp from '../compiled/pkg-up';
+import gzipSize from '../compiled/gzip-size';
+declare const filesize: typeof import('../compiled/filesize');
+declare const stripAnsi: typeof import('../compiled/strip-ansi');
+export { chalk, upath, pkgUp, filesize, stripAnsi, gzipSize };

package/dist/src/compiled.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gzipSize = exports.stripAnsi = exports.filesize = exports.pkgUp = exports.upath = exports.chalk = void 0;
+const chalk_1 = __importDefault(require("../compiled/chalk"));
+exports.chalk = chalk_1.default;
+const upath_1 = __importDefault(require("../compiled/upath"));
+exports.upath = upath_1.default;
+const pkg_up_1 = __importDefault(require("../compiled/pkg-up"));
+exports.pkgUp = pkg_up_1.default;
+const gzip_size_1 = __importDefault(require("../compiled/gzip-size"));
+exports.gzipSize = gzip_size_1.default;
+const import_1 = require("./import");
+const filesize = import_1.Import.lazy('../compiled/filesize', require);
+exports.filesize = filesize;
+const stripAnsi = import_1.Import.lazy('../compiled/strip-ansi', require);
+exports.stripAnsi = stripAnsi;

package/dist/src/constants.d.ts

@@ -0,0 +1,209 @@
+/**
+ * hmr socket connect path
+ */
+export declare const HMR_SOCK_PATH = "/_modern_js_hmr_ws";
+/**
+ * route specification file
+ */
+export declare const ROUTE_SPEC_FILE = "route.json";
+/**
+ * main entry name
+ */
+export declare const MAIN_ENTRY_NAME = "main";
+/**
+ * open editor request path
+ */
+export declare const LAUNCH_EDITOR_ENDPOINT = "/__open-stack-frame-in-editor";
+/**
+ * server side bundles directory, which relative to dist.
+ */
+export declare const SERVER_BUNDLE_DIRECTORY = "bundles";
+/**
+ * entry name pattern used for ajv pattern properties.
+ */
+export declare const ENTRY_NAME_PATTERN = "^[a-zA-Z0-9_-]+$";
+/**
+ * SSR server render function name
+ */
+export declare const SERVER_RENDER_FUNCTION_NAME = "serverRender";
+/**
+ * loadbale manifest json file
+ */
+export declare const LOADABLE_STATS_FILE = "loadable-stats.json";
+/**
+ * internal specified folder
+ */
+export declare const API_DIR = "api";
+export declare const SERVER_DIR = "server";
+export declare const SHARED_DIR = "shared";
+/**
+ * Internal plugins that work as soon as they are installed.
+ */
+export declare const INTERNAL_PLUGINS: {
+    [name: string]: {
+        cli?: string;
+        server?: string;
+    };
+};
+/**
+ * The schema registered in the plugin.
+ */
+export declare const PLUGIN_SCHEMAS: {
+    '@modern-js/runtime': ({
+        target: string;
+        schema: {
+            type: string;
+            additionalProperties: boolean;
+            patternProperties?: undefined;
+        };
+    } | {
+        target: string;
+        schema: {
+            type: string;
+            patternProperties: {
+                "^[a-zA-Z0-9_-]+$": {
+                    type: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+    })[];
+    '@modern-js/plugin-bff': {
+        target: string;
+        schema: {
+            type: string;
+            properties: {
+                prefix: {
+                    type: string[];
+                    items: {
+                        type: string;
+                    };
+                };
+                fetcher: {
+                    type: string;
+                };
+                proxy: {
+                    type: string;
+                };
+                requestCreator: {
+                    type: string;
+                };
+            };
+        };
+    }[];
+    '@modern-js/plugin-esbuild': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-less': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-sass': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-tailwindcss': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-proxy': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-unbundle': ({
+        target: string;
+        schema: {
+            type: string;
+            properties?: undefined;
+        };
+    } | {
+        target: string;
+        schema: {
+            type: string;
+            properties: {
+                ignore: {
+                    type: string[];
+                    items: {
+                        type: string;
+                    };
+                };
+                ignoreModuleCache: {
+                    type: string;
+                };
+                clearPdnCache: {
+                    type: string;
+                };
+                pdnHost: {
+                    type: string;
+                };
+            };
+        };
+    })[];
+    '@modern-js/plugin-ssg': {
+        target: string;
+        schema: {
+            oneOf: ({
+                type: string;
+                instanceof?: undefined;
+            } | {
+                instanceof: string;
+                type?: undefined;
+            })[];
+        };
+    }[];
+    '@modern-js/plugin-ssr': {
+        target: string;
+        schema: {
+            type: string[];
+        };
+    }[];
+    '@modern-js/plugin-state': {
+        target: string;
+        schema: {
+            type: string[];
+        };
+    }[];
+    '@modern-js/plugin-design-token': ({
+        target: string;
+        schema: {
+            typeof: string[];
+            type?: undefined;
+        };
+    } | {
+        target: string;
+        schema: {
+            type: string[];
+            typeof?: undefined;
+        };
+    })[];
+    '@modern-js/plugin-router': {
+        target: string;
+        schema: {
+            type: string[];
+        };
+    }[];
+    '@modern-js/plugin-testing': {
+        target: string;
+        schema: {
+            typeof: string[];
+        };
+    }[];
+    '@modern-js/plugin-garfish': {
+        target: string;
+        schema: {
+            type: string[];
+        };
+    }[];
+    '@modern-js/plugin-nocode': never[];
+};