@modern-js/core 1.8.0 → 1.9.2

package/dist/config/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.resolveConfig = exports.loadUserConfig = exports.defineConfig = exports.addServerConfigToDeps = exports.mergeConfig = exports.defaultsConfig = void 0;
+const load_config_1 = require("@modern-js/load-config");
+const utils_1 = require("@modern-js/utils");
+const lodash_1 = require("@modern-js/utils/lodash");
+const ajv_1 = __importDefault(require("../../compiled/ajv"));
+const ajv_keywords_1 = __importDefault(require("../../compiled/ajv-keywords"));
+const better_ajv_errors_1 = __importDefault(require("../../compiled/better-ajv-errors"));
+const repeatKeyWarning_1 = require("../utils/repeatKeyWarning");
+const defaults_1 = require("./defaults");
+Object.defineProperty(exports, "defaultsConfig", { enumerable: true, get: function () { return defaults_1.defaults; } });
+const mergeConfig_1 = require("./mergeConfig");
+Object.defineProperty(exports, "mergeConfig", { enumerable: true, get: function () { return mergeConfig_1.mergeConfig; } });
+const schema_1 = require("./schema");
+const debug = (0, utils_1.createDebugger)('resolve-config');
+__exportStar(require("./types"), exports);
+const addServerConfigToDeps = (dependencies, appDirectory, serverConfigFile) => __awaiter(void 0, void 0, void 0, function* () {
+    const serverConfig = yield (0, utils_1.getServerConfig)(appDirectory, serverConfigFile);
+    if (serverConfig) {
+        dependencies.push(serverConfig);
+    }
+});
+exports.addServerConfigToDeps = addServerConfigToDeps;
+const defineConfig = (config) => config;
+exports.defineConfig = defineConfig;
+const loadUserConfig = (appDirectory, filePath, packageJsonConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    const loaded = yield (0, load_config_1.loadConfig)(appDirectory, filePath, packageJsonConfig);
+    const config = !loaded
+        ? {}
+        : yield (typeof loaded.config === 'function'
+            ? loaded.config(0)
+            : loaded.config);
+    return {
+        config: (0, lodash_1.mergeWith)({}, config || {}, (loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig) || {}),
+        jsConfig: config || {},
+        pkgConfig: ((loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig) || {}),
+        filePath: loaded === null || loaded === void 0 ? void 0 : loaded.path,
+        dependencies: (loaded === null || loaded === void 0 ? void 0 : loaded.dependencies) || [],
+    };
+});
+exports.loadUserConfig = loadUserConfig;
+const showAdditionalPropertiesError = (error) => {
+    if (error.keyword === 'additionalProperties' &&
+        error.params.additionalProperty) {
+        const target = [
+            error.instancePath.slice(1),
+            error.params.additionalProperty,
+        ]
+            .filter(Boolean)
+            .join('.');
+        const name = Object.keys(utils_1.PLUGIN_SCHEMAS).find(key => utils_1.PLUGIN_SCHEMAS[key].some((schemaItem) => schemaItem.target === target));
+        if (name) {
+            utils_1.signale.warn(`The configuration of ${utils_1.chalk.bold(target)} is provided by plugin ${utils_1.chalk.bold(name)}. Please use ${utils_1.chalk.bold('yarn new')} to enable the corresponding capability.\n`);
+        }
+    }
+};
+const resolveConfig = (loaded, configs, schemas, restartWithExistingPort, argv, onSchemaError = showAdditionalPropertiesError) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { config: userConfig, jsConfig, pkgConfig } = loaded;
+    const ajv = new ajv_1.default({ $data: true, strict: false });
+    (0, ajv_keywords_1.default)(ajv);
+    const validateSchema = (0, schema_1.patchSchema)(schemas);
+    const validate = ajv.compile(validateSchema);
+    (0, repeatKeyWarning_1.repeatKeyWarning)(validateSchema, jsConfig, pkgConfig);
+    // validate user config.
+    const valid = validate(userConfig);
+    if (!valid && ((_a = validate.errors) === null || _a === void 0 ? void 0 : _a.length)) {
+        onSchemaError(validate === null || validate === void 0 ? void 0 : validate.errors[0]);
+        const errors = (0, better_ajv_errors_1.default)(validateSchema, userConfig, (_b = validate.errors) === null || _b === void 0 ? void 0 : _b.map(e => (Object.assign(Object.assign({}, e), { dataPath: e.instancePath }))), {
+            indent: 2,
+        });
+        utils_1.signale.log(errors);
+        throw new Error(`Validate configuration error`);
+    }
+    // validate config from plugins.
+    for (const config of configs) {
+        if (!validate(config)) {
+            utils_1.signale.error(validate.errors);
+            throw new Error(`Validate configuration error.`);
+        }
+    }
+    const resolved = (0, mergeConfig_1.mergeConfig)([defaults_1.defaults, ...configs, userConfig]);
+    resolved._raw = loaded.config;
+    if ((0, utils_1.isDev)() && argv[0] === 'dev') {
+        if (restartWithExistingPort > 0) {
+            // dev server is restarted, should use existing port number
+            resolved.server.port = restartWithExistingPort;
+        }
+        else {
+            // get port for new dev server
+            resolved.server.port = yield (0, utils_1.getPort)(resolved.server.port);
+        }
+    }
+    debug('resolved %o', resolved);
+    return resolved;
+});
+exports.resolveConfig = resolveConfig;

package/dist/config/mergeConfig.d.ts

@@ -0,0 +1,30 @@
+import { UserConfig, SourceConfig, ToolsConfig } from '.';
+export interface NormalizedSourceConfig extends Omit<SourceConfig, 'alias' | 'moduleScopes'> {
+    alias: SourceConfig['alias'] | Array<SourceConfig['alias']>;
+    moduleScopes: SourceConfig['moduleScopes'] | Array<SourceConfig['moduleScopes']>;
+}
+export interface NormalizedToolsConfig extends Omit<ToolsConfig, 'webpack' | 'babel' | 'postcss' | 'autoprefixer' | 'lodash' | 'tsLoader' | 'terser' | 'minifyCss' | 'esbuild' | 'styledComponents'> {
+    webpack: ToolsConfig['webpack'] | Array<NonNullable<ToolsConfig['webpack']>>;
+    babel: ToolsConfig['babel'] | Array<NonNullable<ToolsConfig['babel']>>;
+    postcss: ToolsConfig['postcss'] | Array<NonNullable<ToolsConfig['postcss']>>;
+    styledComponents: ToolsConfig['styledComponents'] | Array<NonNullable<ToolsConfig['styledComponents']>>;
+    autoprefixer: ToolsConfig['autoprefixer'] | Array<NonNullable<ToolsConfig['autoprefixer']>>;
+    lodash: ToolsConfig['lodash'] | Array<ToolsConfig['lodash']>;
+    tsLoader: ToolsConfig['tsLoader'] | Array<NonNullable<ToolsConfig['tsLoader']>>;
+    terser: ToolsConfig['terser'] | Array<NonNullable<ToolsConfig['terser']>>;
+    minifyCss: ToolsConfig['minifyCss'] | Array<NonNullable<ToolsConfig['minifyCss']>>;
+    esbuild: ToolsConfig['esbuild'] | Array<NonNullable<ToolsConfig['esbuild']>>;
+}
+export interface NormalizedConfig extends Omit<Required<UserConfig>, 'source' | 'tools'> {
+    source: NormalizedSourceConfig;
+    tools: NormalizedToolsConfig;
+    cliOptions?: Record<string, any>;
+    _raw: UserConfig;
+}
+/**
+ * merge configuration from  modern.config.js and plugins.
+ *
+ * @param configs - Configuration from modern.config.ts or plugin's config hook.
+ * @returns - normalized user config.
+ */
+export declare const mergeConfig: (configs: Array<UserConfig | NormalizedConfig>) => NormalizedConfig;

package/dist/config/mergeConfig.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeConfig = void 0;
+const lodash_1 = require("@modern-js/utils/lodash");
+const utils_1 = require("@modern-js/utils");
+/**
+ * merge configuration from  modern.config.js and plugins.
+ *
+ * @param configs - Configuration from modern.config.ts or plugin's config hook.
+ * @returns - normalized user config.
+ */
+const mergeConfig = (configs) => (0, lodash_1.mergeWith)({}, ...configs, (target, source) => {
+    if (Array.isArray(target)) {
+        if (Array.isArray(source)) {
+            return [...target, ...source];
+        }
+        else {
+            return typeof source !== 'undefined' ? [...target, source] : target;
+        }
+    }
+    else if ((0, utils_1.isFunction)(source)) {
+        return typeof target !== 'undefined' ? [target, source] : [source];
+    }
+    return undefined;
+});
+exports.mergeConfig = mergeConfig;

package/dist/config/schema/deploy.d.ts

@@ -0,0 +1,16 @@
+export declare const deploy: {
+    type: string;
+    properties: {
+        domain: {
+            type: string[];
+        };
+        domainByEntries: {
+            type: string;
+            patternProperties: {
+                "^[a-zA-Z0-9_-]+$": {
+                    type: string[];
+                };
+            };
+        };
+    };
+};

package/dist/config/schema/deploy.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const utils_1 = require("@modern-js/utils");
+exports.deploy = {
+    type: 'object',
+    properties: {
+        domain: { type: ['array', 'string'] },
+        domainByEntries: {
+            type: 'object',
+            patternProperties: {
+                [utils_1.ENTRY_NAME_PATTERN]: { type: ['array', 'string'] },
+            },
+        },
+    },
+};

package/dist/config/schema/index.d.ts

@@ -0,0 +1,466 @@
+import type { JSONSchemaType } from '../../../compiled/ajv';
+export interface PluginValidateSchema {
+    target: string;
+    schema: JSONSchemaType<any>;
+}
+export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | PluginValidateSchema[]>) => {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        source: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                entries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            if: {
+                                type: string;
+                            };
+                            then: {
+                                required: string[];
+                                properties: {
+                                    entry: {
+                                        type: string[];
+                                    };
+                                    disableMount: {
+                                        type: string;
+                                    };
+                                    enableFileSystemRoutes: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                            else: {
+                                type: string[];
+                            };
+                        };
+                    };
+                };
+                alias: {
+                    typeof: string[];
+                };
+                disableDefaultEntries: {
+                    type: string;
+                };
+                envVars: {
+                    type: string;
+                };
+                globalVars: {
+                    type: string;
+                };
+                moduleScopes: {
+                    instanceof: string[];
+                };
+                entriesDir: {
+                    type: string;
+                };
+                configDir: {
+                    type: string;
+                };
+                include: {
+                    type: string[];
+                };
+            };
+        };
+        output: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                assetPrefix: {
+                    type: string;
+                };
+                path: {
+                    type: string;
+                };
+                jsPath: {
+                    type: string;
+                };
+                cssPath: {
+                    type: string;
+                };
+                htmlPath: {
+                    type: string;
+                };
+                mediaPath: {
+                    type: string;
+                };
+                mountId: {
+                    type: string;
+                };
+                favicon: {
+                    type: string;
+                };
+                faviconByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string;
+                        };
+                    };
+                };
+                title: {
+                    type: string;
+                };
+                titleByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string;
+                        };
+                    };
+                };
+                meta: {
+                    type: string;
+                };
+                metaByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string;
+                        };
+                    };
+                };
+                inject: {
+                    enum: (string | boolean)[];
+                };
+                injectByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            enum: (string | boolean)[];
+                        };
+                    };
+                };
+                copy: {
+                    type: string;
+                };
+                scriptExt: {
+                    type: string;
+                };
+                disableTsChecker: {
+                    type: string;
+                };
+                disableHtmlFolder: {
+                    type: string;
+                };
+                disableCssModuleExtension: {
+                    type: string;
+                };
+                disableCssExtract: {
+                    type: string;
+                };
+                enableCssModuleTSDeclaration: {
+                    type: string;
+                };
+                disableMinimize: {
+                    type: string;
+                };
+                enableInlineStyles: {
+                    type: string;
+                };
+                enableInlineScripts: {
+                    type: string;
+                };
+                disableSourceMap: {
+                    type: string;
+                };
+                disableInlineRuntimeChunk: {
+                    type: string;
+                };
+                disableAssetsCache: {
+                    type: string;
+                };
+                enableLatestDecorators: {
+                    type: string;
+                };
+                enableTsLoader: {
+                    type: string;
+                };
+                dataUriLimit: {
+                    type: string;
+                };
+                templateParameters: {
+                    type: string;
+                };
+                templateParametersByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string;
+                        };
+                    };
+                };
+                polyfill: {
+                    type: string;
+                    enum: string[];
+                };
+                cssModuleLocalIdentName: {
+                    type: string;
+                };
+                federation: {
+                    type: string;
+                };
+                disableNodePolyfill: {
+                    type: string;
+                };
+                enableModernMode: {
+                    type: string;
+                };
+            };
+        };
+        server: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                port: {
+                    type: string;
+                };
+                ssr: {
+                    if: {
+                        type: string;
+                    };
+                    then: {
+                        properties: {
+                            disableLoadable: {
+                                type: string;
+                            };
+                            disableHelmet: {
+                                type: string;
+                            };
+                            disableRedirect: {
+                                type: string;
+                            };
+                            enableAsyncData: {
+                                type: string;
+                            };
+                            enableProductWarning: {
+                                type: string;
+                            };
+                            timeout: {
+                                type: string;
+                            };
+                            asyncDataTimeout: {
+                                type: string;
+                            };
+                        };
+                    };
+                    else: {
+                        type: string;
+                    };
+                };
+                ssrByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            if: {
+                                type: string;
+                            };
+                            then: {
+                                properties: {
+                                    disableLoadable: {
+                                        type: string;
+                                    };
+                                    disableHelmet: {
+                                        type: string;
+                                    };
+                                    disableRedirect: {
+                                        type: string;
+                                    };
+                                    enableProductWarning: {
+                                        type: string;
+                                    };
+                                    enableAsyncData: {
+                                        type: string;
+                                    };
+                                    timeout: {
+                                        type: string;
+                                    };
+                                    asyncDataTimeout: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                            else: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                routes: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            if: {
+                                type: string;
+                            };
+                            then: {
+                                properties: {
+                                    route: {
+                                        oneOf: ({
+                                            type: string;
+                                            properties: {
+                                                path: {
+                                                    type: string;
+                                                };
+                                                headers: {
+                                                    type: string;
+                                                };
+                                            };
+                                            additionalProperties: boolean;
+                                        } | {
+                                            type: string;
+                                            items?: undefined;
+                                        } | {
+                                            type: string;
+                                            items: {
+                                                oneOf: ({
+                                                    type: string;
+                                                    properties: {
+                                                        path: {
+                                                            type: string;
+                                                        };
+                                                        headers: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    additionalProperties: boolean;
+                                                } | {
+                                                    type: string;
+                                                })[];
+                                            };
+                                        })[];
+                                    };
+                                    disableSpa: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                            else: {
+                                oneOf: ({
+                                    type: string;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                    };
+                                })[];
+                            };
+                        };
+                    };
+                };
+                publicRoutes: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string[];
+                        };
+                    };
+                };
+                baseUrl: {
+                    oneOf: ({
+                        type: string;
+                        items?: undefined;
+                    } | {
+                        type: string;
+                        items: {
+                            type: string;
+                        }[];
+                    })[];
+                };
+                middleware: {
+                    instanceof: string[];
+                };
+                renderHook: {
+                    instanceof: string;
+                };
+                logger: {
+                    type: string[];
+                };
+                metrics: {
+                    type: string[];
+                };
+                proxy: {
+                    type: string;
+                };
+                enableMicroFrontendDebug: {
+                    type: string;
+                };
+            };
+        };
+        deploy: {
+            type: string;
+            properties: {
+                domain: {
+                    type: string[];
+                };
+                domainByEntries: {
+                    type: string;
+                    patternProperties: {
+                        "^[a-zA-Z0-9_-]+$": {
+                            type: string[];
+                        };
+                    };
+                };
+            };
+        };
+        plugins: {
+            type: string;
+            additionalProperties: boolean;
+        };
+        dev: {
+            type: string;
+            properties: {
+                assetPrefix: {
+                    type: string[];
+                };
+                https: {
+                    type: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        tools: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                webpack: {
+                    typeof: string[];
+                };
+                babel: {
+                    typeof: string[];
+                };
+                postcss: {
+                    typeof: string[];
+                };
+                lodash: {
+                    typeof: string[];
+                };
+                devServer: {
+                    type: string;
+                };
+                tsLoader: {
+                    typeof: string[];
+                };
+                autoprefixer: {
+                    typeof: string[];
+                };
+                terser: {
+                    typeof: string[];
+                };
+                minifyCss: {
+                    typeof: string[];
+                };
+                styledComponents: {
+                    typeof: string[];
+                };
+            };
+        };
+    };
+};
+export declare const traverseSchema: (schema: ReturnType<typeof patchSchema>) => string[];