@modern-js/core 1.0.0-alpha.3

package/dist/js/node/config/index.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "defaultsConfig", {
+  enumerable: true,
+  get: function () {
+    return _defaults.defaults;
+  }
+});
+exports.resolveConfig = exports.loadUserConfig = exports.defineConfig = void 0;
+
+var _loadConfig = require("@modern-js/load-config");
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _ajvKeywords = _interopRequireDefault(require("ajv-keywords"));
+
+var _signale = _interopRequireDefault(require("signale"));
+
+var _utils = require("@modern-js/utils");
+
+var _lodash = _interopRequireDefault(require("lodash.mergewith"));
+
+var _betterAjvErrors = _interopRequireDefault(require("better-ajv-errors"));
+
+var _codeFrame = require("@babel/code-frame");
+
+var _repeatKeyWarning = require("../utils/repeatKeyWarning");
+
+var _defaults = require("./defaults");
+
+var _mergeConfig = require("./mergeConfig");
+
+var _schema = require("./schema");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const debug = (0, _utils.createDebugger)('resolve-config');
+
+const defineConfig = config => config;
+
+exports.defineConfig = defineConfig;
+
+const loadUserConfig = async (appDirectory, filePath) => {
+  const loaded = (0, _loadConfig.loadConfig)(appDirectory, filePath);
+  const config = !loaded ? {} : await (typeof loaded.config === 'function' ? loaded.config(0) : loaded.config);
+  return {
+    config: (0, _lodash.default)({}, 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.instancePath && error.params.additionalProperty) {
+    const target = `${error.instancePath.substr(1)}.${error.params.additionalProperty}`;
+    const name = Object.keys(_utils.PLUGIN_SCHEMAS).find(key => _utils.PLUGIN_SCHEMAS[key].some(schemaItem => schemaItem.target === target));
+
+    if (name) {
+      _signale.default.warn(`The configuration of ${_utils.chalk.bold(target)} is provided by plugin ${_utils.chalk.bold(name)}. Please use ${_utils.chalk.bold('yarn new')} to enable the corresponding capability.\n`);
+    }
+  }
+};
+/* eslint-disable max-statements, max-params */
+
+
+const resolveConfig = async (loaded, configs, schemas, isRestart, argv) => {
+  var _validate$errors;
+
+  const {
+    config: userConfig,
+    jsConfig,
+    pkgConfig
+  } = loaded;
+  const ajv = new _ajv.default({
+    $data: true,
+    strict: false
+  });
+  (0, _ajvKeywords.default)(ajv);
+  const validateSchema = (0, _schema.patchSchema)(schemas);
+  const validate = ajv.compile(validateSchema);
+  (0, _repeatKeyWarning.repeatKeyWarning)(validateSchema, jsConfig, pkgConfig); // validate user config.
+
+  const valid = validate(userConfig);
+
+  if (!valid && (_validate$errors = validate.errors) !== null && _validate$errors !== void 0 && _validate$errors.length) {
+    var _validate$errors2;
+
+    showAdditionalPropertiesError(validate === null || validate === void 0 ? void 0 : validate.errors[0]);
+    const errors = (0, _betterAjvErrors.default)(validateSchema, userConfig, (_validate$errors2 = validate.errors) === null || _validate$errors2 === void 0 ? void 0 : _validate$errors2.map(e => _objectSpread(_objectSpread({}, e), {}, {
+      dataPath: e.instancePath
+    })), {
+      format: 'js',
+      indent: 2
+    });
+
+    _signale.default.log((0, _codeFrame.codeFrameColumns)(JSON.stringify(userConfig, null, 2), {
+      start: errors === null || errors === void 0 ? void 0 : errors[0].start,
+      end: errors === null || errors === void 0 ? void 0 : errors[0].end
+    }, {
+      highlightCode: true,
+      message: errors === null || errors === void 0 ? void 0 : errors[0].error
+    }));
+
+    throw new Error(`Validate configuration error`);
+  } // validate config from plugins.
+
+
+  for (const config of configs) {
+    if (!validate(config)) {
+      _signale.default.error(validate.errors);
+
+      throw new Error(`Validate configuration error.`);
+    }
+  }
+
+  const resolved = (0, _mergeConfig.mergeConfig)([_defaults.defaults, ...configs, userConfig]);
+  resolved._raw = loaded.config;
+
+  if ((0, _utils.isDev)() && argv[0] === 'dev' && !isRestart) {
+    resolved.server.port = await (0, _utils.getPort)(resolved.server.port);
+  }
+
+  debug('resolved %o', resolved);
+  return resolved;
+};
+/* eslint-enable max-statements, max-params */
+
+
+exports.resolveConfig = resolveConfig;

package/dist/js/node/config/mergeConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeConfig = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash.mergewith"));
+
+var _utils = require("@modern-js/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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.default)({}, ...configs, (target, source) => {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    return [...target, ...source];
+  }
+
+  if ((0, _utils.isFunction)(source)) {
+    return Array.isArray(target) ? [...target, source] : [target, source].filter(Boolean);
+  }
+
+  return undefined;
+});
+
+exports.mergeConfig = mergeConfig;

package/dist/js/node/config/schema/deploy.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deploy = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const deploy = {
+  type: 'object',
+  properties: {
+    microFrontend: {
+      type: 'object',
+      dependencies: {
+        enableHtmlEntry: {
+          properties: {
+            enableLegacy: {
+              enum: [false]
+            }
+          }
+        }
+      },
+      properties: {
+        enableHtmlEntry: {
+          type: 'boolean'
+        }
+      }
+    },
+    domain: {
+      type: ['array', 'string']
+    },
+    domainByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: ['array', 'string']
+        }
+      }
+    }
+  }
+};
+exports.deploy = deploy;

package/dist/js/node/config/schema/index.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverseSchema = exports.patchSchema = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+var _source = require("./source");
+
+var _output = require("./output");
+
+var _server = require("./server");
+
+var _deploy = require("./deploy");
+
+var _tools = require("./tools");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const debug = (0, _utils.createDebugger)('validate-schema');
+const plugins = {
+  type: 'array',
+  additionalProperties: false
+};
+const dev = {
+  type: 'object',
+  properties: {
+    assetPrefix: {
+      type: ['boolean', 'string']
+    }
+  },
+  additionalProperties: false
+};
+
+const patchSchema = pluginSchemas => {
+  const finalSchema = (0, _lodash.default)({
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      source: _source.source,
+      output: _output.output,
+      server: _server.server,
+      deploy: _deploy.deploy,
+      plugins,
+      dev,
+      tools: _tools.tools
+    }
+  });
+
+  const findTargetNode = props => {
+    let node = finalSchema.properties;
+
+    for (const prop of props) {
+      node = node[prop];
+
+      if (!node || !(0, _utils.isObject)(node)) {
+        throw new Error(`add schema ${props.join('.')} error`);
+      }
+
+      node.properties = node.hasOwnProperty('properties') ? node.properties : {};
+      node = node.properties;
+    }
+
+    return node;
+  };
+
+  const finalPluginSchemas = [];
+  pluginSchemas.forEach(item => {
+    if (Array.isArray(item)) {
+      finalPluginSchemas.push(...item);
+    } else {
+      finalPluginSchemas.push(item);
+    }
+  });
+
+  for (const {
+    target,
+    schema
+  } of finalPluginSchemas) {
+    if (!target) {
+      throw new Error(`should return target property in plugin schema.`);
+    }
+
+    const props = target.split('.');
+    const mountProperty = props.pop();
+    const targetNode = findTargetNode(props);
+
+    if (targetNode.hasOwnProperty(mountProperty)) {
+      throw new Error(`${target} already exists in current validate schema`);
+    }
+
+    targetNode[mountProperty] = (0, _lodash.default)(schema);
+  }
+
+  debug(`final validate schema: %o`, finalSchema);
+  return finalSchema;
+};
+
+exports.patchSchema = patchSchema;
+
+const traverseSchema = schema => {
+  const keys = [];
+
+  const traverse = ({
+    properties
+  }, old = []) => {
+    for (const key of Object.keys(properties)) {
+      const current = [...old, key];
+
+      if (properties[key].type === 'object' && properties[key].properties) {
+        traverse(properties[key], current);
+      } else {
+        keys.push(current.join('.'));
+      }
+    }
+  };
+
+  traverse(schema);
+  return keys;
+};
+
+exports.traverseSchema = traverseSchema;

package/dist/js/node/config/schema/output.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.output = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const output = {
+  type: 'object',
+  additionalProperties: false,
+  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: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: 'string'
+        }
+      }
+    },
+    title: {
+      type: 'string'
+    },
+    titleByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: 'string'
+        }
+      }
+    },
+    meta: {
+      type: 'object'
+    },
+    metaByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: 'object'
+        }
+      }
+    },
+    inject: {
+      enum: [true, 'head', 'body', false]
+    },
+    injectByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          enum: [true, 'head', 'body', false]
+        }
+      }
+    },
+    copy: {
+      type: 'array'
+    },
+    scriptExt: {
+      type: 'object'
+    },
+    disableHtmlFolder: {
+      type: 'boolean'
+    },
+    disableCssModuleExtension: {
+      type: 'boolean'
+    },
+    disableCssExtract: {
+      type: 'boolean'
+    },
+    enableCssModuleTSDeclaration: {
+      type: 'boolean'
+    },
+    disableMinimize: {
+      type: 'boolean'
+    },
+    enableInlineStyles: {
+      type: 'boolean'
+    },
+    enableInlineScripts: {
+      type: 'boolean'
+    },
+    disableSourceMap: {
+      type: 'boolean'
+    },
+    disableInlineRuntimeChunk: {
+      type: 'boolean'
+    },
+    disableAssetsCache: {
+      type: 'boolean'
+    },
+    enableLatestDecorators: {
+      type: 'boolean'
+    },
+    enableUsageBuiltIns: {
+      type: 'boolean'
+    },
+    enableTsLoader: {
+      type: 'boolean'
+    },
+    dataUriLimit: {
+      type: 'number'
+    },
+    templateParameters: {
+      type: 'object'
+    },
+    templateParametersByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: 'object'
+        }
+      }
+    },
+    polyfill: {
+      type: 'string',
+      enum: ['usage', 'entry', 'off', 'ua']
+    },
+    cssModuleLocalIdentName: {
+      type: 'string'
+    },
+    federation: {
+      type: 'object'
+    },
+    disableNodePolyfill: {
+      type: 'boolean'
+    },
+    enableModernMode: {
+      type: 'boolean'
+    }
+  }
+};
+exports.output = output;

package/dist/js/node/config/schema/server.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.server = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const SERVER_ROUTE_OBJECT = {
+  type: 'object',
+  properties: {
+    path: {
+      type: 'string'
+    },
+    headers: {
+      type: 'object'
+    }
+  },
+  additionalProperties: false
+};
+const server = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    port: {
+      type: 'number'
+    },
+    ssr: {
+      if: {
+        type: 'object'
+      },
+      then: {
+        properties: {
+          disableLoadable: {
+            type: 'boolean'
+          },
+          disableHelmet: {
+            type: 'boolean'
+          },
+          disableRedirect: {
+            type: 'boolean'
+          },
+          enableAsyncData: {
+            type: 'boolean'
+          },
+          enableProductWarning: {
+            type: 'boolean'
+          },
+          timeout: {
+            type: 'number'
+          },
+          asyncDataTimeout: {
+            type: 'number'
+          }
+        }
+      },
+      else: {
+        type: 'boolean'
+      }
+    },
+    ssrByEntries: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          if: {
+            type: 'object'
+          },
+          then: {
+            properties: {
+              disableLoadable: {
+                type: 'boolean'
+              },
+              disableHelmet: {
+                type: 'boolean'
+              },
+              disableRedirect: {
+                type: 'boolean'
+              },
+              enableProductWarning: {
+                type: 'boolean'
+              },
+              enableAsyncData: {
+                type: 'boolean'
+              },
+              timeout: {
+                type: 'number'
+              },
+              asyncDataTimeout: {
+                type: 'number'
+              }
+            },
+            additionalProperties: false
+          },
+          else: {
+            type: 'boolean'
+          }
+        }
+      }
+    },
+    routes: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          if: {
+            type: 'object'
+          },
+          then: {
+            properties: {
+              route: {
+                oneOf: [{
+                  type: 'string'
+                }, {
+                  type: 'array',
+                  items: {
+                    oneOf: [{
+                      type: 'string'
+                    }, SERVER_ROUTE_OBJECT]
+                  }
+                }, SERVER_ROUTE_OBJECT]
+              },
+              disableSpa: {
+                type: 'boolean'
+              }
+            },
+            additionalProperties: false
+          },
+          else: {
+            oneOf: [{
+              type: 'string'
+            }, {
+              type: 'array',
+              items: {
+                type: 'string'
+              }
+            }]
+          }
+        }
+      }
+    },
+    publicRoutes: {
+      type: 'object',
+      patternProperties: {
+        [_utils.ENTRY_NAME_PATTERN]: {
+          type: ['string']
+        }
+      }
+    },
+    baseUrl: {
+      oneOf: [{
+        type: 'string'
+      }, {
+        type: 'array',
+        items: [{
+          type: 'string'
+        }]
+      }]
+    },
+    middleware: {
+      instanceof: ['Array', 'Function']
+    },
+    renderHook: {
+      instanceof: 'Function'
+    },
+    logger: {
+      type: 'object'
+    },
+    measure: {
+      type: 'object'
+    },
+    proxy: {
+      type: 'object'
+    }
+  }
+};
+exports.server = server;