validateSchema模块

  首先来看错误检测:

    const webpackOptionsValidationErrors = validateSchema(webpackOptionsSchema, options);
if(webpackOptionsValidationErrors.length) {
throw new WebpackOptionsValidationError(webpackOptionsValidationErrors);
}

  可以注意到,这里传了两个参数,其实第一个参数来源于一个JSON文件:

    const webpackOptionsSchema = require("../schemas/webpackOptionsSchema.json");

  这个JSON文件非常大,可以观察一下部分内容:

{
"plugins": {
"description": "Add additional plugins to the compiler.",
"type": "array"
},
"resolve": {
"description": "Options for the resolver",
"anyOf": [
{
"$ref": "#/definitions/resolve"
}
]
},
"required": [
"entry"
],
"type": "object"
}

  从描述可以猜测,这里的key对应options中的key,value就是检测方式。

  比如说entry放到required代表是必须的,plugins的type为array代表这个键必须是一个数组,而$ref代表一个路径映射,即#/definnitions/resolve。

  在JSON文件的开头有一个definitions,其中resolve对应的内容如下:

{
"definitions": {
"resolve": {
"additionalProperties": false,
"properties": {
"alias": {
// ...
}
// ...
},
"type": "object"
}
}
}

  简单明了,就不多解释了。

  下面进入validateSchema模块,流程如图:

  

  内部代码简化如下:

const Ajv = require("ajv");
const ajv = new Ajv({
errorDataPath: "configuration",
allErrors: true,
verbose: true
});
require("ajv-keywords")(ajv, ["instanceof"]);
require("../schemas/ajv.absolutePath")(ajv); function validateSchema(schema, options) {
// 仍然是多配置与单配置
if(Array.isArray(options)) { /*...*/ }
else {
return validateObject(schema, options);
}
} function validateObject(schema, options) {
// 转换JSON文件
const validate = ajv.compile(schema);
// 检测配置对象
const valid = validate(options);
// 返回错误对象
return valid ? [] : filterErrors(validate.errors);
} function filterErrors(errors) { /*...*/ }
module.exports = validateSchema;

  这里引入的ajv模块是一个工具,就像之前的JSON5一样,作用是将一个JSON配置文件转换成一个对象,用于检测对象的合法性。

  在github上,该工具的Getting started如图所示:

  

  简直跟源码中的使用过程一模一样,所以有兴趣的可以自己去看看教程学一下。

  

  由于JSON十分巨大,所以编译后的对象也十分巨大,这里根据vue脚手架中的配置,只看常规的参数是如何进行检测的,比如说devServer、devtool、entry、module、output、plugins、resolve,测试代码如下:

var Ajv = require('ajv');
const ajv = new Ajv({
errorDataPath: "configuration",
allErrors: true,
verbose: true
});
// 简化后的JSON文件
const json = require('./tmp.json');
const validate = ajv.compile(json);

  打包后尝试获取生成的validate函数,整理后源码如下:

(function(self, RULES, formats, root, refVal, defaults, customRules, co, equal, ucs2length, ValidationError) {
var refVal0 = refVal[0];
// ...
var refVal13 = refVal[13];
var validate = (function(data, dataPath, parentData, parentDataProperty, rootData) {
'use strict';
// 负责收集错误信息
var vErrors = null;
// 负责对错误进行计数
var errors = 0;
if (rootData === undefined) rootData = data;
// 这是根级对象
if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
for (var key0 in data) { /*...*/ }
// 在这里进行检测
// 每出现一个错误errors+1并记录vErrors中
var data1 = data.devServer;
if (data1 !== undefined) { /*...*/ }
var data1 = data.devtool;
if (data1 !== undefined) { /*...*/ }
var data1 = data.entry;
if (data1 === undefined) { /*...*/ }
else { /*...*/ }
var data1 = data.module;
if (data1 !== undefined) { /*...*/ }
var data1 = data.output;
if (data1 !== undefined) { /*...*/ }
var data1 = data.plugins;
if (data1 !== undefined) { /*...*/ }
var data1 = data.resolve;
if (data1 !== undefined) { /*...*/ }
} else { /*...*/ }
validate.errors = vErrors;
// 判断是否产生错误
return errors === 0;
});
return validate;
})

  调用validate(options),options在函数中就相当于那个data,validate会依次从data中取出需要校验的key,按照JSON文件中的规则进行判断。

  这里有一个比较麻烦的点,就是顶部的refVal,由于这是一个内部的IIFE,所以从这里看不出refVal数组如何定义的。凭借我的聪明才智,还是从源码中获取到了对应的定义:

  

  打开后,其实是一堆validate函数,所以就不展开看了。

  其实validate并不只有这么多,其中还可以分为特殊校验器和公共校验器,其中公共校验器不会针对特殊的键来进行校验,在这里可以先列出来。(友情警告:千万不要点开!!!)

refVal1

        if ((data && typeof data === "object" && !Array.isArray(data))) {
if (Object.keys(data).length < 1) {
var err = { keyword: 'minProperties', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf/0/minProperties', params: { limit: 1 }, message: 'should NOT have less than 1 properties', schema: 1, parentSchema: validate.schema.oneOf[0], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var errs__1 = errors;
var valid2 = true;
for (var key1 in data) {
var data1 = data[key1];
var errs_2 = errors;
var errs__2 = errors;
var prevValid2 = false;
var valid2 = false;
var errs_3 = errors;
if (typeof data1 === "string") {
if (ucs2length(data1) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/oneOf/0/additionalProperties/oneOf/0/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: validate.schema.oneOf[0].additionalProperties.oneOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/oneOf/0/additionalProperties/oneOf/0/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.oneOf[0].additionalProperties.oneOf[0].type, parentSchema: validate.schema.oneOf[0].additionalProperties.oneOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
if (valid3) valid2 = prevValid2 = true;
var errs_3 = errors;
var errs__3 = errors;
var valid3 = false;
var errs_4 = errors;
var errs_5 = errors;
if (Array.isArray(data1)) {
if (data1.length < 1) {
var err = { keyword: 'minItems', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/minItems', params: { limit: 1 }, message: 'should NOT have less than 1 items', schema: 1, parentSchema: refVal2, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = true;
if (data1.length > 1) {
var i = data1.length,
j;
outer: for (; i--;) { for (j = i; j--;) { if (equal(data1[i], data1[j])) { valid5 = false; break outer; } } }
}
if (!valid5) {
var err = { keyword: 'uniqueItems', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/uniqueItems', params: { i: i, j: j }, message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)', schema: true, parentSchema: refVal2, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var errs__5 = errors;
var valid5;
for (var i5 = 0; i5 < data1.length; i5++) {
var data2 = data1[i5];
var errs_6 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '[\'' + key1 + '\'][' + i5 + ']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal2.items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '[\'' + key1 + '\'][' + i5 + ']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal2.items.type, parentSchema: refVal2.items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid6 = errors === errs_6;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal2.type, parentSchema: refVal2, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = errors === errs_5;
var valid4 = errors === errs_4;
valid3 = valid3 || valid4;
if (!valid3) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/oneOf/0/additionalProperties/oneOf/1/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.oneOf[0].additionalProperties.oneOf[1].anyOf, parentSchema: validate.schema.oneOf[0].additionalProperties.oneOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__3;
if (vErrors !== null) {
if (errs__3) vErrors.length = errs__3;
else vErrors = null;
}
}
var valid3 = errors === errs_3;
if (valid3 && prevValid2) valid2 = false;
else { if (valid3) valid2 = prevValid2 = true; }
if (!valid2) {
var err = { keyword: 'oneOf', dataPath: (dataPath || '') + '[\'' + key1 + '\']', schemaPath: '#/oneOf/0/additionalProperties/oneOf', params: {}, message: 'should match exactly one schema in oneOf', schema: validate.schema.oneOf[0].additionalProperties.oneOf, parentSchema: validate.schema.oneOf[0].additionalProperties, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__2;
if (vErrors !== null) {
if (errs__2) vErrors.length = errs__2;
else vErrors = null;
}
}
var valid2 = errors === errs_2;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf/0/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.oneOf[0].type, parentSchema: validate.schema.oneOf[0], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
if (valid1) valid0 = prevValid0 = true;
var errs_1 = errors;
if (typeof data === "string") {
if (ucs2length(data) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf/1/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: validate.schema.oneOf[1], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf/1/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.oneOf[1].type, parentSchema: validate.schema.oneOf[1], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
if (valid1 && prevValid0) valid0 = false;
else {
if (valid1) valid0 = prevValid0 = true;
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data)) {
if (data.length < 1) {
var err = { keyword: 'minItems', dataPath: (dataPath || '') + "", schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/minItems', params: { limit: 1 }, message: 'should NOT have less than 1 items', schema: 1, parentSchema: refVal[2], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = true;
if (data.length > 1) {
var i = data.length,
j;
outer: for (; i--;) { for (j = i; j--;) { if (equal(data[i], data[j])) { valid3 = false; break outer; } } }
}
if (!valid3) {
var err = { keyword: 'uniqueItems', dataPath: (dataPath || '') + "", schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/uniqueItems', params: { i: i, j: j }, message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)', schema: true, parentSchema: refVal[2], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data.length; i3++) {
var data1 = data[i3];
var errs_4 = errors;
if (typeof data1 === "string") {
if (ucs2length(data1) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '[' + i3 + ']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[2].items, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '[' + i3 + ']', schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[2].items.type, parentSchema: refVal[2].items, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/definitions/common.nonEmptyArrayOfUniqueStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[2].type, parentSchema: refVal[2], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf/2/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.oneOf[2].anyOf, parentSchema: validate.schema.oneOf[2], data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
if (valid1 && prevValid0) valid0 = false;
else {
if (valid1) valid0 = prevValid0 = true;
var valid1 = true;
if (valid1 && prevValid0) valid0 = false;
else { if (valid1) valid0 = prevValid0 = true; }
}
}
if (!valid0) {
var err = { keyword: 'oneOf', dataPath: (dataPath || '') + "", schemaPath: '#/oneOf', params: {}, message: 'should match exactly one schema in oneOf', schema: validate.schema.oneOf, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__0;
if (vErrors !== null) {
if (errs__0) vErrors.length = errs__0;
else vErrors = null;
}
}

规则:

1.数据可以为字符串、对象、数组

2.字符串必须为非空字符串

3.数组必须是非空数组,元素必须是非空字符串且不能重复

4.如果是对象则至少要有2个键,键的规则满足2、3

refVal3

if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
for (var key0 in data) {
var isAdditional0 = !(false || validate.schema.properties[key0]);
if (isAdditional0) {
valid1 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + "", schemaPath: '#/additionalProperties', params: { additionalProperty: '' + key0 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data1 = data.exprContextCritical;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.exprContextCritical', schemaPath: '#/properties/exprContextCritical/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.exprContextCritical.type, parentSchema: validate.schema.properties.exprContextCritical, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.exprContextRecursive;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.exprContextRecursive', schemaPath: '#/properties/exprContextRecursive/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.exprContextRecursive.type, parentSchema: validate.schema.properties.exprContextRecursive, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
if (data.exprContextRegExp !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
var data1 = data.exprContextRequest;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.exprContextRequest', schemaPath: '#/properties/exprContextRequest/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.exprContextRequest.type, parentSchema: validate.schema.properties.exprContextRequest, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.loaders;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal4(data1, (dataPath || '') + '.loaders', data, 'loaders', rootData)) {
if (vErrors === null) vErrors = refVal4.errors;
else vErrors = vErrors.concat(refVal4.errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.loaders', schemaPath: '#/properties/loaders/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.loaders.anyOf, parentSchema: validate.schema.properties.loaders, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
if (data.noParse !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
if (data.rules !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal[4](data.rules, (dataPath || '') + '.rules', data, 'rules', rootData)) {
if (vErrors === null) vErrors = refVal[4].errors;
else vErrors = vErrors.concat(refVal[4].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
var data1 = data.unknownContextCritical;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.unknownContextCritical', schemaPath: '#/properties/unknownContextCritical/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.unknownContextCritical.type, parentSchema: validate.schema.properties.unknownContextCritical, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.unknownContextRecursive;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.unknownContextRecursive', schemaPath: '#/properties/unknownContextRecursive/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.unknownContextRecursive.type, parentSchema: validate.schema.properties.unknownContextRecursive, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
if (data.unknownContextRegExp !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
var data1 = data.unknownContextRequest;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.unknownContextRequest', schemaPath: '#/properties/unknownContextRequest/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.unknownContextRequest.type, parentSchema: validate.schema.properties.unknownContextRequest, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
if (data.unsafeCache !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
var data1 = data.wrappedContextCritical;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.wrappedContextCritical', schemaPath: '#/properties/wrappedContextCritical/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.wrappedContextCritical.type, parentSchema: validate.schema.properties.wrappedContextCritical, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.wrappedContextRecursive;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.wrappedContextRecursive', schemaPath: '#/properties/wrappedContextRecursive/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.wrappedContextRecursive.type, parentSchema: validate.schema.properties.wrappedContextRecursive, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.strictExportPresence;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.strictExportPresence', schemaPath: '#/properties/strictExportPresence/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.strictExportPresence.type, parentSchema: validate.schema.properties.strictExportPresence, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.strictThisContextOnImports;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.strictThisContextOnImports', schemaPath: '#/properties/strictThisContextOnImports/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.strictThisContextOnImports.type, parentSchema: validate.schema.properties.strictThisContextOnImports, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.type, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}

规则:

1.检测了大量不知道的属性

2.loaders,rules属性调用refVal4校验

refVal4

if (Array.isArray(data)) {
var errs__0 = errors;
var valid0;
for (var i0 = 0; i0 < data.length; i0++) {
var data1 = data[i0];
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal5(data1, (dataPath || '') + '[' + i0 + ']', data, i0, rootData)) {
if (vErrors === null) vErrors = refVal5.errors;
else vErrors = vErrors.concat(refVal5.errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '[' + i0 + ']', schemaPath: '#/items/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.items.anyOf, parentSchema: validate.schema.items, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/type', params: { type: 'array' }, message: 'should be array', schema: validate.schema.type, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}

规则:

1.必须为数组

2.数组元素调用refVal5校验

refVal5

if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
for (var key0 in data) {
var isAdditional0 = !(false || validate.schema.properties[key0]);
if (isAdditional0) {
valid1 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + "", schemaPath: '#/additionalProperties', params: { additionalProperty: '' + key0 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data1 = data.enforce;
if (data1 !== undefined) {
var errs_1 = errors;
var schema1 = validate.schema.properties.enforce.enum;
var valid1;
valid1 = false;
for (var i1 = 0; i1 < schema1.length; i1++)
if (equal(data1, schema1[i1])) { valid1 = true; break; }
if (!valid1) {
var err = { keyword: 'enum', dataPath: (dataPath || '') + '.enforce', schemaPath: '#/properties/enforce/enum', params: { allowedValues: schema1 }, message: 'should be equal to one of the allowed values', schema: validate.schema.properties.enforce.enum, parentSchema: validate.schema.properties.enforce, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
if (data.exclude !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal6(data.exclude, (dataPath || '') + '.exclude', data, 'exclude', rootData)) {
if (vErrors === null) vErrors = refVal6.errors;
else vErrors = vErrors.concat(refVal6.errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
if (data.include !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal[6](data.include, (dataPath || '') + '.include', data, 'include', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
if (data.issuer !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal[6](data.issuer, (dataPath || '') + '.issuer', data, 'issuer', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
var data1 = data.loader;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (typeof data1 === "string") {
if (ucs2length(data1) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.loader', schemaPath: '#/definitions/ruleSet-loader/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal7, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.loader', schemaPath: '#/definitions/ruleSet-loader/type', params: { type: 'string' }, message: 'should be string', schema: refVal7.type, parentSchema: refVal7, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if (!refVal8(data1, (dataPath || '') + '.loader', data, 'loader', rootData)) {
if (vErrors === null) vErrors = refVal8.errors;
else vErrors = vErrors.concat(refVal8.errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.loader', schemaPath: '#/properties/loader/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.loader.anyOf, parentSchema: validate.schema.properties.loader, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.loaders;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[8](data1, (dataPath || '') + '.loaders', data, 'loaders', rootData)) {
if (vErrors === null) vErrors = refVal[8].errors;
else vErrors = vErrors.concat(refVal[8].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.loaders', schemaPath: '#/properties/loaders/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.loaders.anyOf, parentSchema: validate.schema.properties.loaders, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.oneOf;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[4](data1, (dataPath || '') + '.oneOf', data, 'oneOf', rootData)) {
if (vErrors === null) vErrors = refVal[4].errors;
else vErrors = vErrors.concat(refVal[4].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.oneOf', schemaPath: '#/properties/oneOf/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.oneOf.anyOf, parentSchema: validate.schema.properties.oneOf, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.options;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
var errs__3 = errors;
var valid3 = false;
var errs_4 = errors;
if ((!data1 || typeof data1 !== "object" || Array.isArray(data1))) {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.options', schemaPath: '#/definitions/ruleSet-query/anyOf/0/type', params: { type: 'object' }, message: 'should be object', schema: refVal9.anyOf[0].type, parentSchema: refVal9.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
valid3 = valid3 || valid4;
if (!valid3) {
var errs_4 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.options', schemaPath: '#/definitions/ruleSet-query/anyOf/1/type', params: { type: 'string' }, message: 'should be string', schema: refVal9.anyOf[1].type, parentSchema: refVal9.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
valid3 = valid3 || valid4;
}
if (!valid3) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.options', schemaPath: '#/definitions/ruleSet-query/anyOf', params: {}, message: 'should match some schema in anyOf', schema: refVal9.anyOf, parentSchema: refVal9, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__3;
if (vErrors !== null) {
if (errs__3) vErrors.length = errs__3;
else vErrors = null;
}
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.options', schemaPath: '#/properties/options/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.options.anyOf, parentSchema: validate.schema.properties.options, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.parser;
if (data1 !== undefined) {
var errs_1 = errors;
if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) { var errs__1 = errors; var valid2 = true; } else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.parser', schemaPath: '#/properties/parser/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.parser.type, parentSchema: validate.schema.properties.parser, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.query;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
var errs__3 = errors;
var valid3 = false;
var errs_4 = errors;
if ((!data1 || typeof data1 !== "object" || Array.isArray(data1))) {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.query', schemaPath: '#/definitions/ruleSet-query/anyOf/0/type', params: { type: 'object' }, message: 'should be object', schema: refVal[9].anyOf[0].type, parentSchema: refVal[9].anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
valid3 = valid3 || valid4;
if (!valid3) {
var errs_4 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.query', schemaPath: '#/definitions/ruleSet-query/anyOf/1/type', params: { type: 'string' }, message: 'should be string', schema: refVal[9].anyOf[1].type, parentSchema: refVal[9].anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
valid3 = valid3 || valid4;
}
if (!valid3) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.query', schemaPath: '#/definitions/ruleSet-query/anyOf', params: {}, message: 'should match some schema in anyOf', schema: refVal[9].anyOf, parentSchema: refVal[9], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__3;
if (vErrors !== null) {
if (errs__3) vErrors.length = errs__3;
else vErrors = null;
}
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.query', schemaPath: '#/properties/query/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.query.anyOf, parentSchema: validate.schema.properties.query, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
if (data.resource !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal[6](data.resource, (dataPath || '') + '.resource', data, 'resource', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
var data1 = data.resourceQuery;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[6](data1, (dataPath || '') + '.resourceQuery', data, 'resourceQuery', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.resourceQuery', schemaPath: '#/properties/resourceQuery/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.resourceQuery.anyOf, parentSchema: validate.schema.properties.resourceQuery, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.compiler;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[6](data1, (dataPath || '') + '.compiler', data, 'compiler', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.compiler', schemaPath: '#/properties/compiler/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.compiler.anyOf, parentSchema: validate.schema.properties.compiler, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.rules;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[4](data1, (dataPath || '') + '.rules', data, 'rules', rootData)) {
if (vErrors === null) vErrors = refVal[4].errors;
else vErrors = vErrors.concat(refVal[4].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.rules', schemaPath: '#/properties/rules/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.rules.anyOf, parentSchema: validate.schema.properties.rules, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
if (data.test !== undefined) {
var errs_1 = errors;
var errs_2 = errors;
if (!refVal[6](data.test, (dataPath || '') + '.test', data, 'test', rootData)) {
if (vErrors === null) vErrors = refVal[6].errors;
else vErrors = vErrors.concat(refVal[6].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
var valid1 = errors === errs_1;
}
var data1 = data.use;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (!refVal[8](data1, (dataPath || '') + '.use', data, 'use', rootData)) {
if (vErrors === null) vErrors = refVal[8].errors;
else vErrors = vErrors.concat(refVal[8].errors);
errors = vErrors.length;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.use', schemaPath: '#/properties/use/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.use.anyOf, parentSchema: validate.schema.properties.use, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.type, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}

规则:

1.必须为对象

2.exclude、include、test调用refVal6

3.loader为非空字符串

4.loaders调用refVal8

5.options必须为对象

6.rules调用refVal4

refVal6

var validate = (function(data, dataPath, parentData, parentDataProperty, rootData) {
'use strict';
validate.errors = null;
return true;
});

规则:

refVal8

var validate = (function(data, dataPath, parentData, parentDataProperty, rootData) {
'use strict';
validate.errors = null;
return true;
});

规则:

refVal10

if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
for (var key0 in data) {
var isAdditional0 = !(false || validate.schema.properties[key0]);
if (isAdditional0) {
valid1 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + "", schemaPath: '#/additionalProperties', params: { additionalProperty: '' + key0 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data1 = data.auxiliaryComment;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment', schemaPath: '#/properties/auxiliaryComment/anyOf/0/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.auxiliaryComment.anyOf[0].type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
var errs__2 = errors;
var valid3 = true;
for (var key2 in data1) {
var isAdditional2 = !(false || key2 == 'amd' || key2 == 'commonjs' || key2 == 'commonjs2' || key2 == 'root');
if (isAdditional2) {
valid3 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + '.auxiliaryComment', schemaPath: '#/properties/auxiliaryComment/anyOf/1/additionalProperties', params: { additionalProperty: '' + key2 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data2 = data1.amd;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment.amd', schemaPath: '#/properties/auxiliaryComment/anyOf/1/properties/amd/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.amd.type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.amd, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
var data2 = data1.commonjs;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment.commonjs', schemaPath: '#/properties/auxiliaryComment/anyOf/1/properties/commonjs/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.commonjs.type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.commonjs, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
var data2 = data1.commonjs2;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment.commonjs2', schemaPath: '#/properties/auxiliaryComment/anyOf/1/properties/commonjs2/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.commonjs2.type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.commonjs2, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
var data2 = data1.root;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment.root', schemaPath: '#/properties/auxiliaryComment/anyOf/1/properties/root/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.root.type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1].properties.root, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.auxiliaryComment', schemaPath: '#/properties/auxiliaryComment/anyOf/1/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.auxiliaryComment.anyOf[1].type, parentSchema: validate.schema.properties.auxiliaryComment.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.auxiliaryComment', schemaPath: '#/properties/auxiliaryComment/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.auxiliaryComment.anyOf, parentSchema: validate.schema.properties.auxiliaryComment, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.chunkFilename;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.chunkFilename', schemaPath: '#/properties/chunkFilename/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.chunkFilename.type, parentSchema: validate.schema.properties.chunkFilename, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.crossOriginLoading;
if (data1 !== undefined) {
var errs_1 = errors;
var schema1 = validate.schema.properties.crossOriginLoading.enum;
var valid1;
valid1 = false;
for (var i1 = 0; i1 < schema1.length; i1++)
if (equal(data1, schema1[i1])) { valid1 = true; break; }
if (!valid1) {
var err = { keyword: 'enum', dataPath: (dataPath || '') + '.crossOriginLoading', schemaPath: '#/properties/crossOriginLoading/enum', params: { allowedValues: schema1 }, message: 'should be equal to one of the allowed values', schema: validate.schema.properties.crossOriginLoading.enum, parentSchema: validate.schema.properties.crossOriginLoading, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.chunkLoadTimeout;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "number") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.chunkLoadTimeout', schemaPath: '#/properties/chunkLoadTimeout/type', params: { type: 'number' }, message: 'should be number', schema: validate.schema.properties.chunkLoadTimeout.type, parentSchema: validate.schema.properties.chunkLoadTimeout, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
if (data.devtoolFallbackModuleFilenameTemplate !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
var data1 = data.devtoolLineToLine;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.devtoolLineToLine', schemaPath: '#/properties/devtoolLineToLine/anyOf/0/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.devtoolLineToLine.anyOf[0].type, parentSchema: validate.schema.properties.devtoolLineToLine.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if ((!data1 || typeof data1 !== "object" || Array.isArray(data1))) {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.devtoolLineToLine', schemaPath: '#/properties/devtoolLineToLine/anyOf/1/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.devtoolLineToLine.anyOf[1].type, parentSchema: validate.schema.properties.devtoolLineToLine.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.devtoolLineToLine', schemaPath: '#/properties/devtoolLineToLine/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.devtoolLineToLine.anyOf, parentSchema: validate.schema.properties.devtoolLineToLine, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
if (data.devtoolModuleFilenameTemplate !== undefined) { var errs_1 = errors; var valid1 = errors === errs_1; }
var data1 = data.filename;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.filename', schemaPath: '#/properties/filename/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.filename.type, parentSchema: validate.schema.properties.filename, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hashDigest;
if (data1 !== undefined) {
var errs_1 = errors;
var schema1 = validate.schema.properties.hashDigest.enum;
var valid1;
valid1 = false;
for (var i1 = 0; i1 < schema1.length; i1++)
if (equal(data1, schema1[i1])) { valid1 = true; break; }
if (!valid1) {
var err = { keyword: 'enum', dataPath: (dataPath || '') + '.hashDigest', schemaPath: '#/properties/hashDigest/enum', params: { allowedValues: schema1 }, message: 'should be equal to one of the allowed values', schema: validate.schema.properties.hashDigest.enum, parentSchema: validate.schema.properties.hashDigest, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hashDigestLength;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 === "number") {
if (data1 < 1 || data1 !== data1) {
var err = { keyword: 'minimum', dataPath: (dataPath || '') + '.hashDigestLength', schemaPath: '#/properties/hashDigestLength/minimum', params: { comparison: '>=', limit: 1, exclusive: false }, message: 'should be >= 1', schema: 1, parentSchema: validate.schema.properties.hashDigestLength, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hashDigestLength', schemaPath: '#/properties/hashDigestLength/type', params: { type: 'number' }, message: 'should be number', schema: validate.schema.properties.hashDigestLength.type, parentSchema: validate.schema.properties.hashDigestLength, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hashFunction;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 === "string") {
if (ucs2length(data1) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.hashFunction', schemaPath: '#/properties/hashFunction/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: validate.schema.properties.hashFunction, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hashFunction', schemaPath: '#/properties/hashFunction/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.hashFunction.type, parentSchema: validate.schema.properties.hashFunction, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hashSalt;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 === "string") {
if (ucs2length(data1) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.hashSalt', schemaPath: '#/properties/hashSalt/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: validate.schema.properties.hashSalt, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hashSalt', schemaPath: '#/properties/hashSalt/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.hashSalt.type, parentSchema: validate.schema.properties.hashSalt, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hotUpdateChunkFilename;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hotUpdateChunkFilename', schemaPath: '#/properties/hotUpdateChunkFilename/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.hotUpdateChunkFilename.type, parentSchema: validate.schema.properties.hotUpdateChunkFilename, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hotUpdateFunction;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hotUpdateFunction', schemaPath: '#/properties/hotUpdateFunction/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.hotUpdateFunction.type, parentSchema: validate.schema.properties.hotUpdateFunction, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.hotUpdateMainFilename;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.hotUpdateMainFilename', schemaPath: '#/properties/hotUpdateMainFilename/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.hotUpdateMainFilename.type, parentSchema: validate.schema.properties.hotUpdateMainFilename, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.jsonpFunction;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.jsonpFunction', schemaPath: '#/properties/jsonpFunction/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.jsonpFunction.type, parentSchema: validate.schema.properties.jsonpFunction, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.library;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library', schemaPath: '#/properties/library/anyOf/0/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.library.anyOf[0].type, parentSchema: validate.schema.properties.library.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if (Array.isArray(data1)) {
var errs__2 = errors;
var valid2;
for (var i2 = 0; i2 < data1.length; i2++) {
var data2 = data1[i2];
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library[' + i2 + ']', schemaPath: '#/properties/library/anyOf/1/items/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.library.anyOf[1].items.type, parentSchema: validate.schema.properties.library.anyOf[1].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library', schemaPath: '#/properties/library/anyOf/1/type', params: { type: 'array' }, message: 'should be array', schema: validate.schema.properties.library.anyOf[1].type, parentSchema: validate.schema.properties.library.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
var errs__2 = errors;
var valid3 = true;
for (var key2 in data1) {
var isAdditional2 = !(false || key2 == 'root' || key2 == 'amd' || key2 == 'commonjs');
if (isAdditional2) {
valid3 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + '.library', schemaPath: '#/properties/library/anyOf/2/additionalProperties', params: { additionalProperty: '' + key2 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema.properties.library.anyOf[2], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data2 = data1.root;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library.root', schemaPath: '#/properties/library/anyOf/2/properties/root/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.library.anyOf[2].properties.root.type, parentSchema: validate.schema.properties.library.anyOf[2].properties.root, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
var data2 = data1.amd;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library.amd', schemaPath: '#/properties/library/anyOf/2/properties/amd/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.library.anyOf[2].properties.amd.type, parentSchema: validate.schema.properties.library.anyOf[2].properties.amd, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
var data2 = data1.commonjs;
if (data2 !== undefined) {
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library.commonjs', schemaPath: '#/properties/library/anyOf/2/properties/commonjs/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.library.anyOf[2].properties.commonjs.type, parentSchema: validate.schema.properties.library.anyOf[2].properties.commonjs, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.library', schemaPath: '#/properties/library/anyOf/2/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.library.anyOf[2].type, parentSchema: validate.schema.properties.library.anyOf[2], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.library', schemaPath: '#/properties/library/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.library.anyOf, parentSchema: validate.schema.properties.library, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.libraryTarget;
if (data1 !== undefined) {
var errs_1 = errors;
var schema1 = validate.schema.properties.libraryTarget.enum;
var valid1;
valid1 = false;
for (var i1 = 0; i1 < schema1.length; i1++)
if (equal(data1, schema1[i1])) { valid1 = true; break; }
if (!valid1) {
var err = { keyword: 'enum', dataPath: (dataPath || '') + '.libraryTarget', schemaPath: '#/properties/libraryTarget/enum', params: { allowedValues: schema1 }, message: 'should be equal to one of the allowed values', schema: validate.schema.properties.libraryTarget.enum, parentSchema: validate.schema.properties.libraryTarget, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.libraryExport;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.libraryExport', schemaPath: '#/properties/libraryExport/anyOf/0/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.libraryExport.anyOf[0].type, parentSchema: validate.schema.properties.libraryExport.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.libraryExport[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal11.items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.libraryExport[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal11.items.type, parentSchema: refVal11.items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.libraryExport', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal11.type, parentSchema: refVal11, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.libraryExport', schemaPath: '#/properties/libraryExport/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.libraryExport.anyOf, parentSchema: validate.schema.properties.libraryExport, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.path;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.path', schemaPath: '#/properties/path/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.path.type, parentSchema: validate.schema.properties.path, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.pathinfo;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.pathinfo', schemaPath: '#/properties/pathinfo/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.pathinfo.type, parentSchema: validate.schema.properties.pathinfo, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.publicPath;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.publicPath', schemaPath: '#/properties/publicPath/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.publicPath.type, parentSchema: validate.schema.properties.publicPath, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.sourceMapFilename;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.sourceMapFilename', schemaPath: '#/properties/sourceMapFilename/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.sourceMapFilename.type, parentSchema: validate.schema.properties.sourceMapFilename, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.sourcePrefix;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.sourcePrefix', schemaPath: '#/properties/sourcePrefix/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.sourcePrefix.type, parentSchema: validate.schema.properties.sourcePrefix, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.strictModuleExceptionHandling;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.strictModuleExceptionHandling', schemaPath: '#/properties/strictModuleExceptionHandling/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.strictModuleExceptionHandling.type, parentSchema: validate.schema.properties.strictModuleExceptionHandling, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.umdNamedDefine;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.umdNamedDefine', schemaPath: '#/properties/umdNamedDefine/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.umdNamedDefine.type, parentSchema: validate.schema.properties.umdNamedDefine, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.type, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}

规则:

1.额外键检测

2.chunkFilename、filename、path、publicPath必须为字符串

3.crossOriginLoading必须是false、"anonymous"、"use-credentials"之一

4.chunkLoadTimeout必须是数字

refVal12

if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
for (var key0 in data) {
var isAdditional0 = !(false || validate.schema.properties[key0]);
if (isAdditional0) {
valid1 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + "", schemaPath: '#/additionalProperties', params: { additionalProperty: '' + key0 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data1 = data.alias;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
var errs__2 = errors;
var valid3 = true;
for (var key2 in data1) {
var data2 = data1[key2];
var errs_3 = errors;
if (typeof data2 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias[\'' + key2 + '\']', schemaPath: '#/properties/alias/anyOf/0/additionalProperties/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.alias.anyOf[0].additionalProperties.type, parentSchema: validate.schema.properties.alias.anyOf[0].additionalProperties, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias', schemaPath: '#/properties/alias/anyOf/0/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.alias.anyOf[0].type, parentSchema: validate.schema.properties.alias.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if (Array.isArray(data1)) {
var errs__2 = errors;
var valid2;
for (var i2 = 0; i2 < data1.length; i2++) {
var data2 = data1[i2];
var errs_3 = errors;
if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
var errs__3 = errors;
var valid4 = true;
for (var key3 in data2) {
var isAdditional3 = !(false || key3 == 'alias' || key3 == 'name' || key3 == 'onlyModule');
if (isAdditional3) {
valid4 = false;
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') + '.alias[' + i2 + ']', schemaPath: '#/properties/alias/anyOf/1/items/additionalProperties', params: { additionalProperty: '' + key3 + '' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema.properties.alias.anyOf[1].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
var data3 = data2.alias;
if (data3 !== undefined) {
var errs_4 = errors;
if (typeof data3 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias[' + i2 + '].alias', schemaPath: '#/properties/alias/anyOf/1/items/properties/alias/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.alias.anyOf[1].items.properties.alias.type, parentSchema: validate.schema.properties.alias.anyOf[1].items.properties.alias, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
var data3 = data2.name;
if (data3 !== undefined) {
var errs_4 = errors;
if (typeof data3 !== "string") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias[' + i2 + '].name', schemaPath: '#/properties/alias/anyOf/1/items/properties/name/type', params: { type: 'string' }, message: 'should be string', schema: validate.schema.properties.alias.anyOf[1].items.properties.name.type, parentSchema: validate.schema.properties.alias.anyOf[1].items.properties.name, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
var data3 = data2.onlyModule;
if (data3 !== undefined) {
var errs_4 = errors;
if (typeof data3 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias[' + i2 + '].onlyModule', schemaPath: '#/properties/alias/anyOf/1/items/properties/onlyModule/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.alias.anyOf[1].items.properties.onlyModule.type, parentSchema: validate.schema.properties.alias.anyOf[1].items.properties.onlyModule, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias[' + i2 + ']', schemaPath: '#/properties/alias/anyOf/1/items/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.alias.anyOf[1].items.type, parentSchema: validate.schema.properties.alias.anyOf[1].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.alias', schemaPath: '#/properties/alias/anyOf/1/type', params: { type: 'array' }, message: 'should be array', schema: validate.schema.properties.alias.anyOf[1].type, parentSchema: validate.schema.properties.alias.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.alias', schemaPath: '#/properties/alias/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.alias.anyOf, parentSchema: validate.schema.properties.alias, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.aliasFields;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
var errs__4 = errors;
var valid4 = false;
var errs_5 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.aliasFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/0/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal13.items.anyOf[0], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.aliasFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/0/type', params: { type: 'string' }, message: 'should be string', schema: refVal13.items.anyOf[0].type, parentSchema: refVal13.items.anyOf[0], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = errors === errs_5;
valid4 = valid4 || valid5;
if (!valid4) {
var errs_5 = errors;
if (Array.isArray(data2)) {
var errs__5 = errors;
var valid5;
for (var i5 = 0; i5 < data2.length; i5++) {
var data3 = data2[i5];
var errs_6 = errors;
if (typeof data3 === "string") {
if (ucs2length(data3) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.aliasFields[' + i3 + '][' + i5 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal13.items.anyOf[1].items, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.aliasFields[' + i3 + '][' + i5 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal13.items.anyOf[1].items.type, parentSchema: refVal13.items.anyOf[1].items, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid6 = errors === errs_6;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.aliasFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/type', params: { type: 'array' }, message: 'should be array', schema: refVal13.items.anyOf[1].type, parentSchema: refVal13.items.anyOf[1], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = errors === errs_5;
valid4 = valid4 || valid5;
}
if (!valid4) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.aliasFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf', params: {}, message: 'should match some schema in anyOf', schema: refVal13.items.anyOf, parentSchema: refVal13.items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__4;
if (vErrors !== null) {
if (errs__4) vErrors.length = errs__4;
else vErrors = null;
}
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.aliasFields', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal13.type, parentSchema: refVal13, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.aliasFields', schemaPath: '#/properties/aliasFields/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.aliasFields.anyOf, parentSchema: validate.schema.properties.aliasFields, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.cacheWithContext;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.cacheWithContext', schemaPath: '#/properties/cacheWithContext/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.cacheWithContext.type, parentSchema: validate.schema.properties.cacheWithContext, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.descriptionFiles;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.descriptionFiles[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.descriptionFiles[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[11].items.type, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.descriptionFiles', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[11].type, parentSchema: refVal[11], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.descriptionFiles', schemaPath: '#/properties/descriptionFiles/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.descriptionFiles.anyOf, parentSchema: validate.schema.properties.descriptionFiles, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.enforceExtension;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.enforceExtension', schemaPath: '#/properties/enforceExtension/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.enforceExtension.type, parentSchema: validate.schema.properties.enforceExtension, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.enforceModuleExtension;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.enforceModuleExtension', schemaPath: '#/properties/enforceModuleExtension/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.enforceModuleExtension.type, parentSchema: validate.schema.properties.enforceModuleExtension, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.extensions;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.extensions[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.extensions[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[11].items.type, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.extensions', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[11].type, parentSchema: refVal[11], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.extensions', schemaPath: '#/properties/extensions/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.extensions.anyOf, parentSchema: validate.schema.properties.extensions, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.mainFields;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
var errs__4 = errors;
var valid4 = false;
var errs_5 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.mainFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/0/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[13].items.anyOf[0], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/0/type', params: { type: 'string' }, message: 'should be string', schema: refVal[13].items.anyOf[0].type, parentSchema: refVal[13].items.anyOf[0], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = errors === errs_5;
valid4 = valid4 || valid5;
if (!valid4) {
var errs_5 = errors;
if (Array.isArray(data2)) {
var errs__5 = errors;
var valid5;
for (var i5 = 0; i5 < data2.length; i5++) {
var data3 = data2[i5];
var errs_6 = errors;
if (typeof data3 === "string") {
if (ucs2length(data3) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.mainFields[' + i3 + '][' + i5 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[13].items.anyOf[1].items, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFields[' + i3 + '][' + i5 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[13].items.anyOf[1].items.type, parentSchema: refVal[13].items.anyOf[1].items, data: data3 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid6 = errors === errs_6;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf/1/type', params: { type: 'array' }, message: 'should be array', schema: refVal[13].items.anyOf[1].type, parentSchema: refVal[13].items.anyOf[1], data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid5 = errors === errs_5;
valid4 = valid4 || valid5;
}
if (!valid4) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.mainFields[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/items/anyOf', params: {}, message: 'should match some schema in anyOf', schema: refVal[13].items.anyOf, parentSchema: refVal[13].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__4;
if (vErrors !== null) {
if (errs__4) vErrors.length = errs__4;
else vErrors = null;
}
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFields', schemaPath: '#/definitions/common.arrayOfStringOrStringArrayValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[13].type, parentSchema: refVal[13], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.mainFields', schemaPath: '#/properties/mainFields/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.mainFields.anyOf, parentSchema: validate.schema.properties.mainFields, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.mainFiles;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.mainFiles[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFiles[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[11].items.type, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.mainFiles', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[11].type, parentSchema: refVal[11], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.mainFiles', schemaPath: '#/properties/mainFiles/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.mainFiles.anyOf, parentSchema: validate.schema.properties.mainFiles, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.moduleExtensions;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.moduleExtensions[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.moduleExtensions[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[11].items.type, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.moduleExtensions', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[11].type, parentSchema: refVal[11], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.moduleExtensions', schemaPath: '#/properties/moduleExtensions/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.moduleExtensions.anyOf, parentSchema: validate.schema.properties.moduleExtensions, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.modules;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
var errs_3 = errors;
if (Array.isArray(data1)) {
var errs__3 = errors;
var valid3;
for (var i3 = 0; i3 < data1.length; i3++) {
var data2 = data1[i3];
var errs_4 = errors;
if (typeof data2 === "string") {
if (ucs2length(data2) < 1) {
var err = { keyword: 'minLength', dataPath: (dataPath || '') + '.modules[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/minLength', params: { limit: 1 }, message: 'should NOT be shorter than 1 characters', schema: 1, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.modules[' + i3 + ']', schemaPath: '#/definitions/common.arrayOfStringValues/items/type', params: { type: 'string' }, message: 'should be string', schema: refVal[11].items.type, parentSchema: refVal[11].items, data: data2 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid4 = errors === errs_4;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.modules', schemaPath: '#/definitions/common.arrayOfStringValues/type', params: { type: 'array' }, message: 'should be array', schema: refVal[11].type, parentSchema: refVal[11], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid3 = errors === errs_3;
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.modules', schemaPath: '#/properties/modules/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.modules.anyOf, parentSchema: validate.schema.properties.modules, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.plugins;
if (data1 !== undefined) {
var errs_1 = errors;
if (!Array.isArray(data1)) {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.plugins', schemaPath: '#/properties/plugins/type', params: { type: 'array' }, message: 'should be array', schema: validate.schema.properties.plugins.type, parentSchema: validate.schema.properties.plugins, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.symlinks;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.symlinks', schemaPath: '#/properties/symlinks/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.symlinks.type, parentSchema: validate.schema.properties.symlinks, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
var data1 = data.unsafeCache;
if (data1 !== undefined) {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.unsafeCache', schemaPath: '#/properties/unsafeCache/anyOf/0/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.unsafeCache.anyOf[0].type, parentSchema: validate.schema.properties.unsafeCache.anyOf[0], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) {
var errs_2 = errors;
if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) { var errs__2 = errors; var valid3 = true; } else {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.unsafeCache', schemaPath: '#/properties/unsafeCache/anyOf/1/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.properties.unsafeCache.anyOf[1].type, parentSchema: validate.schema.properties.unsafeCache.anyOf[1], data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
if (!valid1) {
var err = { keyword: 'anyOf', dataPath: (dataPath || '') + '.unsafeCache', schemaPath: '#/properties/unsafeCache/anyOf', params: {}, message: 'should match some schema in anyOf', schema: validate.schema.properties.unsafeCache.anyOf, parentSchema: validate.schema.properties.unsafeCache, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
} else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}
var data1 = data.useSyncFileSystemCalls;
if (data1 !== undefined) {
var errs_1 = errors;
if (typeof data1 !== "boolean") {
var err = { keyword: 'type', dataPath: (dataPath || '') + '.useSyncFileSystemCalls', schemaPath: '#/properties/useSyncFileSystemCalls/type', params: { type: 'boolean' }, message: 'should be boolean', schema: validate.schema.properties.useSyncFileSystemCalls.type, parentSchema: validate.schema.properties.useSyncFileSystemCalls, data: data1 };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
var valid1 = errors === errs_1;
}
} else {
var err = { keyword: 'type', dataPath: (dataPath || '') + "", schemaPath: '#/type', params: { type: 'object' }, message: 'should be object', schema: validate.schema.type, parentSchema: validate.schema, data: data };
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}

规则:

1.必须是对象

2.额外键检测

3.alias可以是对象、数组

4.alias为数组时,数组元素必须是对象,且键必须为alias、name、onlyModule之一

5.键为alias、name的值必须是字符串,键为onlyModule的值必须为布尔值

6.extensions必须是数组,数组元素必须是非空字符串

  由于可选参数过于庞大,所以的代码只展示常用的属性校验,剔除大量陌生属性,不然实在是太长了!!!!!!!!

1、rootObject

  首先是根对象的检测:

// 对象判断
if ((data && typeof data === "object" && !Array.isArray(data))) {
var errs__0 = errors;
var valid1 = true;
// 遍历key
for (var key0 in data) {
// 这里检测属性中是否有检测范围外的键
var isAdditional0 = !(false || validate.schema.properties[key0]);
if (isAdditional0) {
valid1 = false;
// 生成报错信息
var err = { keyword: 'additionalProperties', dataPath: (dataPath || '') +
"", schemaPath: '#/additionalProperties', params: { additionalProperty: '' +
key0 +
'' }, message: 'should NOT have additional properties', schema: false, parentSchema: validate.schema, data: data };
// 第一次产生错误时初始化vErrors为数组
if (vErrors === null) vErrors = [err];
else vErrors.push(err);
errors++;
}
}
} else{ /*添加错误*/ }

  这里还有一个validate.schema.properties对象,通过翻源码找到了定义:

  

  一句话概括就是,在根对象中会检测是否有多余的键,可以测试一下:

const validate = ajv.compile(json);
const valid = validate({
"unexpectedKey":0,
});
console.log(validate.errors);

  输出内容如下:

  

2、devServer

var data1 = data.devServer;
// 存在键就继续检测
// 由于是非必须项 所以没有也不报错
if (data1 !== undefined) {
var errs_1 = errors;
// 检测是是对象
if ((!data1 || typeof data1 !== "object" || Array.isArray(data1))) {
// 生成报错信息
}
// 如果检测后总错误数量不变 说明通过
var valid1 = errors === errs_1;
}

  一句话概括:如果存在该键则必须为对象。

3、devtool

var data1 = data.devtool;
if (data1 !== undefined) {
var valid1 = false;
// 标记初始值
var errs_1 = errors;
// 用于记录错误
var errs__1 = errors;
var errs_2 = errors;
// 判断字符串
if (typeof data1 !== "string") { /*添加错误*/ }
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
// 如果上面报错进入这里
if (!valid1) {
var errs_2 = errors;
// 获取枚举数组
var schema2 = validate.schema.properties.devtool.anyOf[1].enum;
var valid2;
valid2 = false;
// 遍历判断是否匹配元素
for (var i2 = 0; i2 < schema2.length; i2++)
if (equal(data1, schema2[i2])) { valid2 = true; break; }
if (!valid2) { /*添加错误*/ }
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
}
// 即非字符串也不是枚举数组元素
if (!valid1) { /*添加错误*/ }
// 如果有一个符合就回滚错误数量 验证通过
else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}

  其中枚举数组如图:  

  一句话概括:devtool可以为字符串或者false。

4、entry

var data1 = data.entry;
// 检测键是否存在
if (data1 === undefined) { /*添加错误*/ }
else {
var errs_1 = errors;
var errs__1 = errors;
var valid1 = false;
var errs_2 = errors;
// refVal1
if (!refVal1(data1, (dataPath || '') + '.entry', data, 'entry', rootData)) { /*添加错误*/ }
var valid2 = errors === errs_2;
valid1 = valid1 || valid2;
if (!valid1) { /*添加错误*/ }
// 通过
else {
errors = errs__1;
if (vErrors !== null) {
if (errs__1) vErrors.length = errs__1;
else vErrors = null;
}
}
var valid1 = errors === errs_1;
}

  调用了refVal1校验器,不愿意看上面的代码可以直接看规则。

5、module => refVal3

6、output => refVal10

7、plugins

var data1 = data.plugins;
if (data1 !== undefined) {
var errs_1 = errors;
// 必须是数组
if (!Array.isArray(data1)) { /**/ }
var valid1 = errors === errs_1;
}

8、resolve => refVal12

  真是又臭又长,再返回validate校验函数后,会进行校验 :

    const valid = validate(options);
return valid ? [] : filterErrors(validate.errors);

  根据是否有错误返回true或false,由于在检测的时候已经对错误进行了收集,所以可以直接从 validate.errors 获取,这里的过滤就不看了,恶心的不行。

  然后会返回到webpack主函数:

    const webpackOptionsValidationErrors = validateSchema(webpackOptionsSchema, options);
if (webpackOptionsValidationErrors.length) {
throw new WebpackOptionsValidationError(webpackOptionsValidationErrors);
}

  根据 webpackOptionsValidationErrors 的长度来判断是否有错误,有错则抛出并中止编译。

完事!

.6-浅析webpack源码之validateSchema模块的更多相关文章

  1. .4-浅析webpack源码之convert-argv模块

    上一节看了一眼预编译的总体代码,这一节分析convert-argv模块. 这个模块主要是对命令参数的解析,也是yargs框架的核心用处. 生成默认配置文件名数组 module.exports = fu ...

  2. .9-浅析webpack源码之NodeEnvironmentPlugin模块总览

    介绍Compiler的构造比较无趣,不如先过后面的,在用到compiler的时候再做讲解. 这一节主要讲这行代码: // 不管这里 compiler = new Compiler(); compile ...

  3. .15-浅析webpack源码之WebpackOptionsApply模块-plugin事件流总览

    总体过了一下后面的流程,发现Compiler模块确实不适合单独讲解,这里继续讲解后面的代码: compiler.options = new WebpackOptionsApply().process( ...

  4. .14-浅析webpack源码之Watchpack模块

    解决掉了最头疼的DirectoryWatcher内部实现,这一节可以结束NodeWatchFileSystem模块. 关于watch的应用场景,仔细思考了下,这不就是热重载的核心嘛. 首先是监视文件, ...

  5. .13-浅析webpack源码之WatcherManager模块

    从模块流可以看出,这个NodeWatchFileSystem模块非常深,这里暂时不会深入到chokidar模块,有点太偏离本系列文章了,从WatcherManager开始讲解. 流程如图: 源码非常简 ...

  6. .12-浅析webpack源码之NodeWatchFileSystem模块总览

    剩下一个watch模块,这个模块比较深,先大概过一下整体涉及内容再分部讲解. 流程图如下: NodeWatchFileSystem const Watchpack = require("wa ...

  7. .11-浅析webpack源码之Storage模块

    至此已完成NodeJsInputFileSysten模块的讲解,下一步就是实际实用的模块: compiler.inputFileSystem = new CachedInputFileSystem(n ...

  8. .10-浅析webpack源码之graceful-fs模块

    在cachedInput.output.watch三大文件系统中,output非常简单,没有必要讲,其余两个模块依赖于input模块,而input主要是引用了graceful-fs的部分API,所以这 ...

  9. .7-浅析webpack源码之WebpackOptionsDefaulter模块

    WebpackOptionsDefaulter模块 通过参数检测后,会根据单/多配置进行处理,本文基于单配置,所以会进行到如下代码: if (Array.isArray(options)) { com ...

随机推荐

  1. OpenCV+Qt+CMake安装+十种踩坑

    平台:win10 x64+opencv-3.4.1 + qt-x86-5.9.0 + cmake3.13.4 x64 OpenCV+Qt+CMake安装,及目前安装完后打包:mingw32-make时 ...

  2. shell脚本中跳转另一台主机执行命令 <<EOF

    ssh vmuser@ <<EOFmkdir /home/vmuser/xunjianrm /home/vmuser/xunjian/xj.logtouch /home/vmuser/xu ...

  3. 11. English vocabulary 英语词汇量

    11. English vocabulary 英语词汇量 (1) The exact number of English words is not known.The large dictionari ...

  4. javabean的特点

    javabean的三个基础条件 1.拥有私有的属性 2.共有的get,set方法 3.默认的构造方法

  5. 给JavaScript24条最佳实践

    作为“30 HTML和CSS最佳实践”的后续,这篇文章将回顾JavaScript的知识 !如果你看完了下面的内容,请务必让我们知道你掌握的小技巧! 1.使用 === 代替 == JavaScript ...

  6. Java设计模式----解释器模式

    计算器中,我们输入“20 + 10 - 5”,计算器会得出结果25并返回给我们.可你有没有想过计算器是怎样完成四则运算的?或者说,计算器是怎样识别你输入的这串字符串信息,并加以解析,然后执行之,得出结 ...

  7. springMVC 处理json 及 HttpMessageConverter 接口

    一.SpringMVC处理json的使用 1.添加依赖jar包 <dependency> <groupId>com.fasterxml.jackson.core</gro ...

  8. php安装扩展的几种方法

    转自:http://doc3.workerman.net/appendices/install-extension.html 安装扩展 注意 与Apache+PHP或者Nginx+PHP的运行模式不同 ...

  9. CentOS No manual entry for man 没有 xx 的手册页条目

    yum install -y man man-pages man-pages-overrides https://unix.stackexchange.com/questions/182500/no- ...

  10. Android 使用 HTTPS 问题解决(SSLHandshakeException)

    title date categories tags Android 5.0以下TLS1.x SSLHandshakeException 2016-11-30 12:17:02 -0800 Andro ...