@modern-js/utils 1.3.7 → 1.5.0

package/dist/FileSizeReporter.js

@@ -0,0 +1,151 @@
+/* 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 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, compiled_1.recursiveReaddir)(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/{types/alias.d.ts → alias.d.ts}

@@ -1,23 +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>;
-  };
+    source: {
+        alias?: AliasOption | Array<AliasOption>;
+    };
 }
 interface IAliasConfig {
-  absoluteBaseUrl: string;
-  paths?: Record<string, string | string[]>;
-  isTsPath?: boolean;
-  isTsProject?: boolean;
+    absoluteBaseUrl: string;
+    paths?: Record<string, string | string[]>;
+    isTsPath?: boolean;
+    isTsProject?: boolean;
 }
-export declare const validAlias: <T extends NormalizedConfig>(modernConfig: T, {
-  tsconfigPath
-}: {
-  tsconfigPath: string;
+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;
+    appDirectory: string;
+    tsconfigPath: string;
 }) => IAliasConfig;
 export declare const getUserAlias: (alias?: Record<string, string | string[]>) => Record<string, string | string[]>;
-export {};
+export {};

package/dist/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/analyzeProject.d.ts

@@ -0,0 +1 @@
+export declare const isApiOnly: (appDirectory: string) => Promise<boolean>;

package/dist/analyzeProject.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiOnly = void 0;
+const path = __importStar(require("path"));
+const minimist_1 = __importDefault(require("minimist"));
+const compiled_1 = require("./compiled");
+const isApiOnly = (appDirectory) => __awaiter(void 0, void 0, void 0, function* () {
+    const srcDir = path.join(appDirectory, 'src');
+    const existSrc = yield compiled_1.fs.pathExists(srcDir);
+    const options = (0, minimist_1.default)(process.argv.slice(2));
+    return !existSrc || Boolean(options['api-only']);
+});
+exports.isApiOnly = isApiOnly;

package/dist/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/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/clearConsole.d.ts

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

package/dist/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/{types/compatRequire.d.ts → compatRequire.d.ts}

@@ -5,4 +5,4 @@
  */
 export declare const compatRequire: (filePath: string) => any;
 export declare const requireExistModule: (filename: string, extensions?: string[]) => any;
-export declare const cleanRequireCache: (filelist: string[]) => void;
+export declare const cleanRequireCache: (filelist: string[]) => void;

package/dist/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/compiled.d.ts

@@ -0,0 +1,21 @@
+import fs from '../compiled/fs-extra';
+import chalk from '../compiled/chalk';
+import lodash from '../compiled/lodash';
+import signale from '../compiled/signale';
+export { fs, chalk, lodash, signale };
+export { program, Command } from '../compiled/commander';
+export { Signale, SignaleOptions } from '../compiled/signale';
+export type { IOptions as GlobOptions } from '../compiled/glob';
+export type { FSWatcher, WatchOptions } from '../compiled/chokidar';
+export declare const glob: typeof import('../compiled/glob');
+export declare const yaml: typeof import('../compiled/js-yaml');
+export declare const execa: typeof import('../compiled/execa');
+export declare const pkgUp: typeof import('../compiled/pkg-up');
+export declare const upath: typeof import('../compiled/upath');
+export declare const debug: typeof import('../compiled/debug');
+export declare const chokidar: typeof import('../compiled/chokidar');
+export declare const gzipSize: typeof import('../compiled/gzip-size');
+export declare const filesize: typeof import('../compiled/filesize');
+export declare const stripAnsi: typeof import('../compiled/strip-ansi');
+export declare const browserslist: typeof import('../compiled/browserslist');
+export declare const recursiveReaddir: typeof import('../compiled/recursive-readdir');

package/dist/compiled.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recursiveReaddir = exports.browserslist = exports.stripAnsi = exports.filesize = exports.gzipSize = exports.chokidar = exports.debug = exports.upath = exports.pkgUp = exports.execa = exports.yaml = exports.glob = exports.SignaleOptions = exports.Signale = exports.Command = exports.program = exports.signale = exports.lodash = exports.chalk = exports.fs = void 0;
+const fs_extra_1 = __importDefault(require("../compiled/fs-extra"));
+exports.fs = fs_extra_1.default;
+const chalk_1 = __importDefault(require("../compiled/chalk"));
+exports.chalk = chalk_1.default;
+const lodash_1 = __importDefault(require("../compiled/lodash"));
+exports.lodash = lodash_1.default;
+const signale_1 = __importDefault(require("../compiled/signale"));
+exports.signale = signale_1.default;
+const import_1 = require("./import");
+var commander_1 = require("../compiled/commander");
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return commander_1.program; } });
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return commander_1.Command; } });
+var signale_2 = require("../compiled/signale");
+Object.defineProperty(exports, "Signale", { enumerable: true, get: function () { return signale_2.Signale; } });
+Object.defineProperty(exports, "SignaleOptions", { enumerable: true, get: function () { return signale_2.SignaleOptions; } });
+exports.glob = import_1.Import.lazy('../compiled/glob', require);
+exports.yaml = import_1.Import.lazy('../compiled/js-yaml', require);
+exports.execa = import_1.Import.lazy('../compiled/execa', require);
+exports.pkgUp = import_1.Import.lazy('../compiled/pkg-up', require);
+exports.upath = import_1.Import.lazy('../compiled/upath', require);
+exports.debug = import_1.Import.lazy('../compiled/debug', require);
+exports.chokidar = import_1.Import.lazy('../compiled/chokidar', require);
+exports.gzipSize = import_1.Import.lazy('../compiled/gzip-size', require);
+exports.filesize = import_1.Import.lazy('../compiled/filesize', require);
+exports.stripAnsi = import_1.Import.lazy('../compiled/strip-ansi', require);
+exports.browserslist = import_1.Import.lazy('../compiled/browserslist', require);
+exports.recursiveReaddir = import_1.Import.lazy('../compiled/recursive-readdir', require);

package/dist/constants.d.ts

@@ -0,0 +1,222 @@
+/**
+ * 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";
+/**
+ * Modern.config.ts cached dir
+ */
+export declare const CONFIG_CACHE_DIR = "./node_modules/.cache/node-bundle-require";
+export declare const CONFIG_FILE_EXTENSIONS: string[];
+/**
+ * Serialized config path
+ */
+export declare const OUTPUT_CONFIG_FILE = "modern.config.json";
+/**
+ * Default server config basename
+ */
+export declare const DEFAULT_SERVER_CONFIG = "modern.server-runtime.config";
+/**
+ * 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[];
+};