Add: node_modules

This commit is contained in:
Cutls
2019-09-12 23:38:13 +09:00
parent 4769c83958
commit 25a1db84a4
7934 changed files with 956263 additions and 1 deletions

154
app/node_modules/@develar/schema-utils/CHANGELOG.md generated vendored Normal file
View File

@@ -0,0 +1,154 @@
# Changelog
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
### [2.0.1](https://github.com/webpack-contrib/schema-utils/compare/v2.0.0...v2.0.1) (2019-07-18)
### Bug Fixes
* error message for empty object ([#44](https://github.com/webpack-contrib/schema-utils/issues/44)) ([0b4b4a2](https://github.com/webpack-contrib/schema-utils/commit/0b4b4a2))
### [2.0.0](https://github.com/webpack-contrib/schema-utils/compare/v1.0.0...v2.0.0) (2019-07-17)
### BREAKING CHANGES
* drop support for Node.js < 8.9.0
* drop support `errorMessage`, please use `description` for links.
* api was changed, please look documentation.
* error messages was fully rewritten.
<a name="1.0.0"></a>
# [1.0.0](https://github.com/webpack-contrib/schema-utils/compare/v0.4.7...v1.0.0) (2018-08-07)
### Features
* **src:** add support for custom error messages ([#33](https://github.com/webpack-contrib/schema-utils/issues/33)) ([1cbe4ef](https://github.com/webpack-contrib/schema-utils/commit/1cbe4ef))
<a name="0.4.7"></a>
## [0.4.7](https://github.com/webpack-contrib/schema-utils/compare/v0.4.6...v0.4.7) (2018-08-07)
### Bug Fixes
* **src:** `node >= v4.0.0` support ([#32](https://github.com/webpack-contrib/schema-utils/issues/32)) ([cb13dd4](https://github.com/webpack-contrib/schema-utils/commit/cb13dd4))
<a name="0.4.6"></a>
## [0.4.6](https://github.com/webpack-contrib/schema-utils/compare/v0.4.5...v0.4.6) (2018-08-06)
### Bug Fixes
* **package:** remove lockfile ([#28](https://github.com/webpack-contrib/schema-utils/issues/28)) ([69f1a81](https://github.com/webpack-contrib/schema-utils/commit/69f1a81))
* **package:** remove unnecessary `webpack` dependency ([#26](https://github.com/webpack-contrib/schema-utils/issues/26)) ([532eaa5](https://github.com/webpack-contrib/schema-utils/commit/532eaa5))
<a name="0.4.5"></a>
## [0.4.5](https://github.com/webpack-contrib/schema-utils/compare/v0.4.4...v0.4.5) (2018-02-13)
### Bug Fixes
* **CHANGELOG:** update broken links ([4483b9f](https://github.com/webpack-contrib/schema-utils/commit/4483b9f))
* **package:** update broken links ([f2494ba](https://github.com/webpack-contrib/schema-utils/commit/f2494ba))
<a name="0.4.4"></a>
## [0.4.4](https://github.com/webpack-contrib/schema-utils/compare/v0.4.3...v0.4.4) (2018-02-13)
### Bug Fixes
* **package:** update `dependencies` ([#22](https://github.com/webpack-contrib/schema-utils/issues/22)) ([3aecac6](https://github.com/webpack-contrib/schema-utils/commit/3aecac6))
<a name="0.4.3"></a>
## [0.4.3](https://github.com/webpack-contrib/schema-utils/compare/v0.4.2...v0.4.3) (2017-12-14)
### Bug Fixes
* **validateOptions:** throw `err` instead of `process.exit(1)` ([#17](https://github.com/webpack-contrib/schema-utils/issues/17)) ([c595eda](https://github.com/webpack-contrib/schema-utils/commit/c595eda))
* **ValidationError:** never return `this` in the ctor ([#16](https://github.com/webpack-contrib/schema-utils/issues/16)) ([c723791](https://github.com/webpack-contrib/schema-utils/commit/c723791))
<a name="0.4.2"></a>
## [0.4.2](https://github.com/webpack-contrib/schema-utils/compare/v0.4.1...v0.4.2) (2017-11-09)
### Bug Fixes
* **validateOptions:** catch `ValidationError` and handle it internally ([#15](https://github.com/webpack-contrib/schema-utils/issues/15)) ([9c5ef5e](https://github.com/webpack-contrib/schema-utils/commit/9c5ef5e))
<a name="0.4.1"></a>
## [0.4.1](https://github.com/webpack-contrib/schema-utils/compare/v0.4.0...v0.4.1) (2017-11-03)
### Bug Fixes
* **ValidationError:** use `Error.captureStackTrace` for `err.stack` handling ([#14](https://github.com/webpack-contrib/schema-utils/issues/14)) ([a6fb974](https://github.com/webpack-contrib/schema-utils/commit/a6fb974))
<a name="0.4.0"></a>
# [0.4.0](https://github.com/webpack-contrib/schema-utils/compare/v0.3.0...v0.4.0) (2017-10-28)
### Features
* add support for `typeof`, `instanceof` (`{Function\|RegExp}`) ([#10](https://github.com/webpack-contrib/schema-utils/issues/10)) ([9f01816](https://github.com/webpack-contrib/schema-utils/commit/9f01816))
<a name="0.3.0"></a>
# [0.3.0](https://github.com/webpack-contrib/schema-utils/compare/v0.2.1...v0.3.0) (2017-04-29)
### Features
* add ValidationError ([#8](https://github.com/webpack-contrib/schema-utils/issues/8)) ([d48f0fb](https://github.com/webpack-contrib/schema-utils/commit/d48f0fb))
<a name="0.2.1"></a>
## [0.2.1](https://github.com/webpack-contrib/schema-utils/compare/v0.2.0...v0.2.1) (2017-03-13)
### Bug Fixes
* Include .babelrc to `files` ([28f0363](https://github.com/webpack-contrib/schema-utils/commit/28f0363))
* Include source to `files` ([43b0f2f](https://github.com/webpack-contrib/schema-utils/commit/43b0f2f))
<a name="0.2.0"></a>
# [0.2.0](https://github.com/webpack-contrib/schema-utils/compare/v0.1.0...v0.2.0) (2017-03-12)
<a name="0.1.0"></a>
# 0.1.0 (2017-03-07)
### Features
* **validations:** add validateOptions module ([ae9b47b](https://github.com/webpack-contrib/schema-utils/commit/ae9b47b))
# Change Log
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

20
app/node_modules/@develar/schema-utils/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,20 @@
Copyright JS Foundation and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

256
app/node_modules/@develar/schema-utils/README.md generated vendored Normal file
View File

@@ -0,0 +1,256 @@
<div align="center">
<a href="http://json-schema.org">
<img width="160" height="160"
src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
</a>
<a href="https://github.com/webpack/webpack">
<img width="200" height="200"
src="https://webpack.js.org/assets/icon-square-big.svg">
</a>
</div>
[![npm][npm]][npm-url]
[![node][node]][node-url]
[![deps][deps]][deps-url]
[![tests][tests]][tests-url]
[![coverage][cover]][cover-url]
[![chat][chat]][chat-url]
[![size][size]][size-url]
# schema-utils
Package for validate options in loaders and plugins.
## Getting Started
To begin, you'll need to install `schema-utils`:
```console
npm install schema-utils
```
## API
**schema.json**
```json
{
"type": "object",
"properties": {
"option": {
"type": ["boolean"]
}
},
"additionalProperties": false
}
```
```js
import schema from './path/to/schema.json';
import validate from 'schema-utils';
const options = { option: true };
const configuration = { name: 'Loader Name/Plugin Name/Name' };
validate(schema, options, configuration);
```
### `schema`
Type: `String`
JSON schema.
Simple example of schema:
```json
{
"type": "object",
"properties": {
"name": {
"description": "This is description of option.",
"type": "string"
}
},
"additionalProperties": false
}
```
### `options`
Type: `Object`
Object with options.
```js
validate(
schema,
{
name: 123,
},
{ name: 'MyPlugin' }
);
```
### `configuration`
Allow to configure validator.
#### `name`
Type: `Object`
Default: `"Object"`
Allow to setup name in validation errors.
```js
validate(schema, options, { name: 'MyPlugin' });
```
```shell
Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
- configuration.optionName should be a integer.
```
#### `baseDataPath`
Type: `String`
Default: `"configuration"`
Allow to setup base data path in validation errors.
```js
validate(schema, options, { name: 'MyPlugin', baseDataPath: 'options' });
```
```shell
Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
- options.optionName should be a integer.
```
#### `postFormatter`
Type: `Function`
Default: `undefined`
Allow to reformat errors.
```js
validate(schema, options, {
name: 'MyPlugin',
postFormatter: (formattedError, error) => {
if (error.keyword === 'type') {
return `${formattedError}\nAdditional Information.`;
}
return formattedError;
},
});
```
```shell
Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
- options.optionName should be a integer.
Additional Information.
```
## Examples
**schema.json**
```json
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"test": {
"anyOf": [
{ "type": "array" },
{ "type": "string" },
{ "instanceof": "RegExp" }
]
},
"transform": {
"instanceof": "Function"
},
"sourceMap": {
"type": "boolean"
}
},
"additionalProperties": false
}
```
### `Loader`
```js
import { getOptions } from 'loader-utils';
import validateOptions from 'schema-utils';
import schema from 'path/to/schema.json';
function loader(src, map) {
const options = getOptions(this) || {};
validateOptions(schema, options, {
name: 'Loader Name',
baseDataPath: 'options',
});
// Code...
}
export default loader;
```
### `Plugin`
```js
import validateOptions from 'schema-utils';
import schema from 'path/to/schema.json';
class Plugin {
constructor(options) {
validateOptions(schema, options, {
name: 'Plugin Name',
baseDataPath: 'options',
});
this.options = options;
}
apply(compiler) {
// Code...
}
}
export default Plugin;
```
## Contributing
Please take a moment to read our contributing guidelines if you haven't yet done so.
[CONTRIBUTING](./.github/CONTRIBUTING.md)
## License
[MIT](./LICENSE)
[npm]: https://img.shields.io/npm/v/schema-utils.svg
[npm-url]: https://npmjs.com/package/schema-utils
[node]: https://img.shields.io/node/v/schema-utils.svg
[node-url]: https://nodejs.org
[deps]: https://david-dm.org/webpack/schema-utils.svg
[deps-url]: https://david-dm.org/webpack/schema-utils
[tests]: https://dev.azure.com/webpack/schema-utils/_apis/build/status/webpack.schema-utils?branchName=master
[tests-url]: https://dev.azure.com/webpack/schema-utils/_build/latest?definitionId=9&branchName=master
[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
[cover-url]: https://codecov.io/gh/webpack/schema-utils
[chat]: https://badges.gitter.im/webpack/webpack.svg
[chat-url]: https://gitter.im/webpack/webpack
[size]: https://packagephobia.now.sh/badge?p=schema-utils
[size-url]: https://packagephobia.now.sh/result?p=schema-utils

View File

@@ -0,0 +1,587 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
const SPECIFICITY = {
type: 1,
not: 1,
oneOf: 1,
anyOf: 1,
if: 1,
enum: 1,
const: 1,
instanceof: 1,
required: 2,
pattern: 2,
patternRequired: 2,
format: 2,
formatMinimum: 2,
formatMaximum: 2,
minimum: 2,
exclusiveMinimum: 2,
maximum: 2,
exclusiveMaximum: 2,
multipleOf: 2,
uniqueItems: 2,
contains: 2,
minLength: 2,
maxLength: 2,
minItems: 2,
maxItems: 2,
minProperties: 2,
maxProperties: 2,
dependencies: 2,
propertyNames: 2,
additionalItems: 2,
additionalProperties: 2,
absolutePath: 2
};
function filterMax(array, fn) {
const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
return array.filter(item => fn(item) === evaluatedMax);
}
function filterChildren(children) {
let newChildren = children;
newChildren = filterMax(newChildren, error => error.dataPath ? error.dataPath.length : 0);
newChildren = filterMax(newChildren, error => SPECIFICITY[error.keyword] || 2);
return newChildren;
}
function indent(str, prefix) {
return str.replace(/\n(?!$)/g, `\n${prefix}`);
}
function isObject(maybyObj) {
return typeof maybyObj === 'object' && maybyObj !== null;
}
function likeNumber(schema) {
return schema.type === 'number' || typeof schema.minimum !== 'undefined' || typeof schema.exclusiveMinimum !== 'undefined' || typeof schema.maximum !== 'undefined' || typeof schema.exclusiveMaximum !== 'undefined' || typeof schema.multipleOf !== 'undefined';
}
function likeInteger(schema) {
return schema.type === 'integer' || typeof schema.minimum !== 'undefined' || typeof schema.exclusiveMinimum !== 'undefined' || typeof schema.maximum !== 'undefined' || typeof schema.exclusiveMaximum !== 'undefined' || typeof schema.multipleOf !== 'undefined';
}
function likeString(schema) {
return schema.type === 'string' || typeof schema.minLength !== 'undefined' || typeof schema.maxLength !== 'undefined' || typeof schema.pattern !== 'undefined' || typeof schema.format !== 'undefined' || typeof schema.formatMinimum !== 'undefined' || typeof schema.formatMaximum !== 'undefined';
}
function likeBoolean(schema) {
return schema.type === 'boolean';
}
function likeArray(schema) {
return schema.type === 'array' || typeof schema.minItems === 'number' || typeof schema.maxItems === 'number' || typeof schema.uniqueItems !== 'undefined' || typeof schema.items !== 'undefined' || typeof schema.additionalItems !== 'undefined' || typeof schema.contains !== 'undefined';
}
function likeObject(schema) {
return schema.type === 'object' || typeof schema.minProperties !== 'undefined' || typeof schema.maxProperties !== 'undefined' || typeof schema.required !== 'undefined' || typeof schema.properties !== 'undefined' || typeof schema.patternProperties !== 'undefined' || typeof schema.additionalProperties !== 'undefined' || typeof schema.dependencies !== 'undefined' || typeof schema.propertyNames !== 'undefined' || typeof schema.patternRequired !== 'undefined';
}
function likeNull(schema) {
return schema.type === 'null';
}
function getArticle(type) {
if (/^[aeiou]/i.test(type)) {
return 'an';
}
return 'a';
}
class ValidationError extends Error {
constructor(errors, schema, configuration = {}) {
super();
this.name = 'ValidationError';
this.errors = errors;
this.schema = schema;
this.headerName = configuration.name || 'Object';
this.baseDataPath = configuration.baseDataPath || 'configuration';
this.postFormatter = configuration.postFormatter || null;
const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialised using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
this.message = `${header}${this.formatValidationErrors(errors)}`;
Error.captureStackTrace(this, this.constructor);
}
getSchemaPart(path) {
const newPath = path.split('/');
let schemaPart = this.schema;
for (let i = 1; i < newPath.length; i++) {
const inner = schemaPart[newPath[i]];
if (!inner) {
break;
}
schemaPart = inner;
}
return schemaPart;
}
formatSchema(schema, prevSchemas = []) {
const formatInnerSchema = (innerSchema, addSelf) => {
if (!addSelf) {
return this.formatSchema(innerSchema, prevSchemas);
}
if (prevSchemas.includes(innerSchema)) {
return '(recursive)';
}
return this.formatSchema(innerSchema, prevSchemas.concat(schema));
}; // eslint-disable-next-line default-case
switch (schema.instanceof) {
case 'Function':
return 'function';
case 'RegExp':
return 'RegExp';
}
if (schema.enum) {
return schema.enum.map(item => JSON.stringify(item)).join(' | ');
}
if (typeof schema.const !== 'undefined') {
return JSON.stringify(schema.const);
}
if (schema.oneOf) {
return schema.oneOf.map(formatInnerSchema).join(' | ');
}
if (schema.anyOf) {
return schema.anyOf.map(formatInnerSchema).join(' | ');
}
if (schema.allOf) {
return schema.allOf.map(formatInnerSchema).join(' & ');
}
if (schema.if) {
return `if ${formatInnerSchema(schema.if)} then ${formatInnerSchema(schema.then)}${schema.else ? ` else ${formatInnerSchema(schema.else)}` : ''}`;
}
if (schema.$ref) {
return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
}
if (likeNumber(schema) || likeInteger(schema)) {
const hints = [];
if (typeof schema.minimum === 'number') {
hints.push(`should be >= ${schema.minimum}`);
}
if (typeof schema.exclusiveMinimum === 'number') {
hints.push(`should be > ${schema.exclusiveMinimum}`);
}
if (typeof schema.maximum === 'number') {
hints.push(`should be <= ${schema.maximum}`);
}
if (typeof schema.exclusiveMaximum === 'number') {
hints.push(`should be > ${schema.exclusiveMaximum}`);
}
if (typeof schema.multipleOf === 'number') {
hints.push(`should be multiple of ${schema.multipleOf}`);
}
const type = schema.type === 'integer' ? 'integer' : 'number';
return `${type}${hints.length > 0 ? ` (${hints.join(', ')})` : ''}`;
}
if (likeString(schema)) {
let type = 'string';
const hints = [];
if (typeof schema.minLength === 'number') {
if (schema.minLength === 1) {
type = 'non-empty string';
} else {
hints.push(`should not be shorter than ${schema.minLength} characters`);
}
}
if (typeof schema.maxLength === 'number') {
hints.push(`should not be longer than ${schema.maxLength} character${schema.maxLength > 1 ? 's' : ''}`);
}
if (schema.pattern) {
hints.push(`should match pattern ${JSON.stringify(schema.pattern)}`);
}
if (schema.format) {
hints.push(`should match format ${JSON.stringify(schema.format)}`);
}
if (schema.formatMinimum) {
hints.push(`should be ${schema.formatExclusiveMinimum ? '>' : '>='} ${JSON.stringify(schema.formatMinimum)}`);
}
if (schema.formatMaximum) {
hints.push(`should be ${schema.formatExclusiveMaximum ? '<' : '<='} ${JSON.stringify(schema.formatMaximum)}`);
}
return `${type}${hints.length > 0 ? ` (${hints.join(', ')})` : ''}`;
}
if (likeBoolean(schema)) {
return 'boolean';
}
if (likeArray(schema)) {
const hints = [];
if (typeof schema.minItems === 'number') {
hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? 's' : ''}`);
}
if (typeof schema.maxItems === 'number') {
hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? 's' : ''}`);
}
if (schema.uniqueItems) {
hints.push('should not have duplicate items');
}
const hasAdditionalItems = typeof schema.additionalItems === 'undefined' || Boolean(schema.additionalItems);
let items = '';
if (schema.items) {
if (Array.isArray(schema.items) && schema.items.length > 0) {
items = `${schema.items.map(formatInnerSchema).join(', ')}`;
if (hasAdditionalItems) {
if (isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
}
}
} else if (schema.items && Object.keys(schema.items).length > 0) {
// "additionalItems" is ignored
items = `${formatInnerSchema(schema.items)}`;
} else {
// Fallback for empty `items` value
items = 'any';
}
} else {
// "additionalItems" is ignored
items = 'any';
}
if (schema.contains && Object.keys(schema.contains).length > 0) {
hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
}
return `[${items}${hasAdditionalItems ? ', ...' : ''}]${hints.length > 0 ? ` (${hints.join(', ')})` : ''}`;
}
if (likeObject(schema)) {
const hints = [];
if (typeof schema.minProperties === 'number') {
hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? 'properties' : 'property'}`);
}
if (typeof schema.maxProperties === 'number') {
hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties > 1 ? 'properties' : 'property'}`);
}
if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
const patternProperties = Object.keys(schema.patternProperties);
hints.push(`additional property names should match pattern${patternProperties.length > 1 ? 's' : ''} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(' | ')}`);
}
const properties = schema.properties ? Object.keys(schema.properties) : [];
const required = schema.required ? schema.required : [];
const allProperties = [...new Set([].concat(required).concat(properties))];
const hasAdditionalProperties = typeof schema.additionalProperties === 'undefined' || Boolean(schema.additionalProperties);
const objectStructure = allProperties.map(property => {
const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
// Maybe we should output type of property (`foo: string`), but it is looks very unreadable
return `${property}${isRequired ? '' : '?'}`;
}).concat(hasAdditionalProperties ? isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ['…'] : []).join(', ');
if (schema.dependencies) {
Object.keys(schema.dependencies).forEach(dependencyName => {
const dependency = schema.dependencies[dependencyName];
if (Array.isArray(dependency)) {
hints.push(`should have ${dependency.length > 1 ? 'properties' : 'property'} ${dependency.map(dep => `'${dep}'`).join(', ')} when property '${dependencyName}' is present`);
} else {
hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
}
});
}
if (schema.propertyNames && Object.keys(schema.propertyNames).length > 0) {
hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
}
if (schema.patternRequired && schema.patternRequired.length > 0) {
hints.push(`should have property matching pattern ${schema.patternRequired.map(item => JSON.stringify(item))}`);
}
return `object {${objectStructure ? ` ${objectStructure} ` : ''}}${hints.length > 0 ? ` (${hints.join(', ')})` : ''}`;
}
if (likeNull(schema)) {
return 'null';
}
if (Array.isArray(schema.type)) {
return `${schema.type.map(item => item).join(' | ')}`;
} // Fallback for unknown keywords
/* istanbul ignore next */
return JSON.stringify(schema, null, 2);
}
getSchemaPartText(schemaPart, additionalPath, needDot = false) {
if (additionalPath) {
for (let i = 0; i < additionalPath.length; i++) {
const inner = schemaPart[additionalPath[i]];
if (inner) {
// eslint-disable-next-line no-param-reassign
schemaPart = inner;
} else {
break;
}
}
}
while (schemaPart.$ref) {
// eslint-disable-next-line no-param-reassign
schemaPart = this.getSchemaPart(schemaPart.$ref);
}
let schemaText = `${this.formatSchema(schemaPart)}${needDot ? '.' : ''}`;
if (schemaPart.description) {
schemaText += `\n-> ${schemaPart.description}`;
}
return schemaText;
}
getSchemaPartDescription(schemaPart) {
while (schemaPart.$ref) {
// eslint-disable-next-line no-param-reassign
schemaPart = this.getSchemaPart(schemaPart.$ref);
}
if (schemaPart.description) {
return `\n-> ${schemaPart.description}`;
}
return '';
}
formatValidationError(error) {
const dataPath = `${this.baseDataPath}${error.dataPath}`;
switch (error.keyword) {
case 'type':
// eslint-disable-next-line default-case
switch (error.params.type) {
case 'number':
return `${dataPath} should be a ${this.getSchemaPartText(error.parentSchema, false, true)}`;
case 'integer':
return `${dataPath} should be a ${this.getSchemaPartText(error.parentSchema, false, true)}`;
case 'string':
return `${dataPath} should be a ${this.getSchemaPartText(error.parentSchema, false, true)}`;
case 'boolean':
return `${dataPath} should be a ${this.getSchemaPartText(error.parentSchema, false, true)}`;
case 'array':
return `${dataPath} should be an array:\n${this.getSchemaPartText(error.parentSchema)}`;
case 'object':
return `${dataPath} should be an object:\n${this.getSchemaPartText(error.parentSchema)}`;
case 'null':
return `${dataPath} should be a ${this.getSchemaPartText(error.parentSchema, false, true)}`;
default:
return `${dataPath} should be:\n${this.getSchemaPartText(error.parentSchema)}`;
}
case 'instanceof':
return `${dataPath} should be an instance of ${this.getSchemaPartText(error.parentSchema)}.`;
case 'pattern':
return `${dataPath} should match pattern ${JSON.stringify(error.params.pattern)}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'format':
return `${dataPath} should match format ${JSON.stringify(error.params.format)}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'formatMinimum':
case 'formatMaximum':
return `${dataPath} should be ${error.params.comparison} ${JSON.stringify(error.params.limit)}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'minimum':
case 'maximum':
case 'exclusiveMinimum':
case 'exclusiveMaximum':
return `${dataPath} should be ${error.params.comparison} ${error.params.limit}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'multipleOf':
return `${dataPath} should be multiple of ${error.params.multipleOf}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'patternRequired':
return `${dataPath} should have property matching pattern ${JSON.stringify(error.params.missingPattern)}.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'minLength':
{
if (error.params.limit === 1) {
return `${dataPath} should be an non-empty string.${this.getSchemaPartDescription(error.parentSchema)}`;
}
return `${dataPath} should not be shorter than ${error.params.limit} characters.${this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'minItems':
{
if (error.params.limit === 1) {
return `${dataPath} should be an non-empty array.${this.getSchemaPartDescription(error.parentSchema)}`;
}
return `${dataPath} should not have fewer than ${error.params.limit} items.${this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'minProperties':
{
if (error.params.limit === 1) {
return `${dataPath} should be an non-empty object.${this.getSchemaPartDescription(error.parentSchema)}`;
}
return `${dataPath} should not have fewer than ${error.params.limit} properties.${this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'maxLength':
return `${dataPath} should not be longer than ${error.params.limit} characters.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'maxItems':
return `${dataPath} should not have more than ${error.params.limit} items.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'maxProperties':
return `${dataPath} should not have more than ${error.params.limit} properties.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'uniqueItems':
return `${dataPath} should not contain the item '${error.data[error.params.i]}' twice.${this.getSchemaPartDescription(error.parentSchema)}`;
case 'additionalItems':
return `${dataPath} should not have more than ${error.params.limit} items. These items are valid:\n${this.getSchemaPartText(error.parentSchema)}`;
case 'contains':
return `${dataPath} should contains at least one ${this.getSchemaPartText(error.parentSchema, ['contains'])} item.`;
case 'required':
{
const missingProperty = error.params.missingProperty.replace(/^\./, '');
const hasProperty = Boolean(error.parentSchema.properties && error.parentSchema.properties[missingProperty]);
return `${dataPath} misses the property '${missingProperty}'.${hasProperty ? ` Should be:\n${this.getSchemaPartText(error.parentSchema, ['properties', missingProperty])}` : this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'additionalProperties':
return `${dataPath} has an unknown property '${error.params.additionalProperty}'. These properties are valid:\n${this.getSchemaPartText(error.parentSchema)}`;
case 'dependencies':
{
const dependencies = error.params.deps.split(',').map(dep => `'${dep.trim()}'`).join(', ');
return `${dataPath} should have properties ${dependencies} when property '${error.params.property}' is present.${this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'propertyNames':
{
const invalidProperty = error.params.propertyName;
return `${dataPath} property name '${invalidProperty}' is invalid. Property names should be match format ${JSON.stringify(error.schema.format)}.${this.getSchemaPartDescription(error.parentSchema)}`;
}
case 'enum':
{
if (error.parentSchema && error.parentSchema.enum && error.parentSchema.enum.length === 1) {
return `${dataPath} should be ${this.getSchemaPartText(error.parentSchema, false, true)}`;
}
return `${dataPath} should be one of these:\n${this.getSchemaPartText(error.parentSchema)}`;
}
case 'const':
return `${dataPath} should be equal to constant ${this.getSchemaPartText(error.parentSchema)}`;
case 'oneOf':
case 'anyOf':
{
if (error.children && error.children.length > 0) {
if (error.schema.length === 1) {
const lastChild = error.children[error.children.length - 1];
const remainingChildren = error.children.slice(0, error.children.length - 1);
return this.formatValidationError(Object.assign({}, lastChild, {
children: remainingChildren,
parentSchema: Object.assign({}, error.parentSchema, lastChild.parentSchema)
}));
}
const children = filterChildren(error.children);
if (children.length === 1) {
return this.formatValidationError(children[0]);
}
return `${dataPath} should be one of these:\n${this.getSchemaPartText(error.parentSchema)}\nDetails:\n${children.map(nestedError => ` * ${indent(this.formatValidationError(nestedError), ' ')}`).join('\n')}`;
}
return `${dataPath} should be one of these:\n${this.getSchemaPartText(error.parentSchema)}`;
}
case 'if':
return `${dataPath} should match "${error.params.failingKeyword}" schema:\n${this.getSchemaPartText(error.parentSchema, [error.params.failingKeyword])}`;
case 'absolutePath':
return `${dataPath}: ${error.message}${this.getSchemaPartDescription(error.parentSchema)}`;
default:
// For `custom`, `false schema`, `$ref` keywords
// Fallback for unknown keywords
/* istanbul ignore next */
return `${dataPath} ${error.message} (${JSON.stringify(error, null, 2)}).\n${this.getSchemaPartText(error.parentSchema)}`;
}
}
formatValidationErrors(errors) {
return errors.map(error => {
let formattedError = this.formatValidationError(error, this.schema);
if (this.postFormatter) {
formattedError = this.postFormatter(formattedError, error);
}
return ` - ${indent(formattedError, ' ')}`;
}).join('\n');
}
}
var _default = ValidationError;
exports.default = _default;

5
app/node_modules/@develar/schema-utils/dist/index.js generated vendored Normal file
View File

@@ -0,0 +1,5 @@
"use strict";
const validate = require('./validate');
module.exports = validate.default;

View File

@@ -0,0 +1,53 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
function errorMessage(schema, data, message) {
return {
keyword: 'absolutePath',
params: {
absolutePath: data
},
message,
parentSchema: schema
};
}
function getErrorFor(shouldBeAbsolute, data, schema) {
const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
return errorMessage(schema, data, message);
}
var _default = ajv => ajv.addKeyword('absolutePath', {
errors: true,
type: 'string',
compile(expected, schema) {
function callback(data) {
let passes = true;
const isExclamationMarkPresent = data.includes('!');
const isCorrectAbsoluteOrRelativePath = expected === /^(?:[A-Za-z]:\\|\/)/.test(data);
if (isExclamationMarkPresent) {
callback.errors = [errorMessage(schema, data, `The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`)];
passes = false;
}
if (!isCorrectAbsoluteOrRelativePath) {
callback.errors = [getErrorFor(expected, data, schema)];
passes = false;
}
return passes;
}
callback.errors = [];
return callback;
}
});
exports.default = _default;

View File

@@ -0,0 +1,96 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _ajv = _interopRequireDefault(require("ajv"));
var _ajvKeywords = _interopRequireDefault(require("ajv-keywords"));
var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
var _ValidationError = _interopRequireDefault(require("./ValidationError"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const ajv = new _ajv.default({
allErrors: true,
verbose: true,
coerceTypes: true
});
(0, _ajvKeywords.default)(ajv, ['instanceof', 'formatMinimum', 'formatMaximum', 'patternRequired']); // Custom keywords
(0, _absolutePath.default)(ajv);
function validate(schema, options, configuration = {}) {
let errors = [];
if (Array.isArray(options)) {
errors = options.map(nestedOptions => validateObject(schema, nestedOptions));
errors.forEach((list, idx) => {
const applyPrefix = error => {
// eslint-disable-next-line no-param-reassign
error.dataPath = `[${idx}]${error.dataPath}`;
if (error.children) {
error.children.forEach(applyPrefix);
}
};
list.forEach(applyPrefix);
});
errors = errors.reduce((arr, items) => arr.concat(items), []);
} else {
errors = validateObject(schema, options);
}
if (errors.length > 0) {
throw new _ValidationError.default(errors, schema, configuration);
}
return errors;
}
function validateObject(schema, options) {
const compiledSchema = ajv.compile(schema);
const valid = compiledSchema(options);
return valid ? [] : filterErrors(compiledSchema.errors);
}
function filterErrors(errors) {
let newErrors = [];
for (const error of errors) {
const {
dataPath
} = error;
let children = [];
newErrors = newErrors.filter(oldError => {
if (oldError.dataPath.includes(dataPath)) {
if (oldError.children) {
children = children.concat(oldError.children.slice(0));
} // eslint-disable-next-line no-undefined, no-param-reassign
oldError.children = undefined;
children.push(oldError);
return false;
}
return true;
});
if (children.length) {
error.children = children;
}
newErrors.push(error);
}
return newErrors;
}
var _default = validate;
exports.default = _default;

101
app/node_modules/@develar/schema-utils/package.json generated vendored Normal file
View File

@@ -0,0 +1,101 @@
{
"_from": "@develar/schema-utils@~2.1.0",
"_id": "@develar/schema-utils@2.1.0",
"_inBundle": false,
"_integrity": "sha512-qjCqB4ctMig9Gz5bd6lkdFr3bO6arOdQqptdBSpF1ZpCnjofieCciEzkoS9ujY9cMGyllYSCSmBJ3x9OKHXzoA==",
"_location": "/@develar/schema-utils",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@develar/schema-utils@~2.1.0",
"name": "@develar/schema-utils",
"escapedName": "@develar%2fschema-utils",
"scope": "@develar",
"rawSpec": "~2.1.0",
"saveSpec": null,
"fetchSpec": "~2.1.0"
},
"_requiredBy": [
"/app-builder-lib"
],
"_resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.1.0.tgz",
"_shasum": "eceb1695bfbed6f6bb84666d5d3abe5e1fd54e17",
"_spec": "@develar/schema-utils@~2.1.0",
"_where": "C:\\Users\\ryuki\\TheDesk\\app\\node_modules\\app-builder-lib",
"author": {
"name": "webpack Contrib",
"url": "https://github.com/webpack-contrib"
},
"bugs": {
"url": "https://github.com/webpack-contrib/schema-utils/issues"
},
"bundleDependencies": false,
"dependencies": {
"ajv": "^6.1.0",
"ajv-keywords": "^3.1.0"
},
"deprecated": false,
"description": "webpack Validation Utils",
"devDependencies": {
"@babel/cli": "^7.4.4",
"@babel/core": "^7.4.5",
"@babel/preset-env": "^7.4.5",
"@commitlint/cli": "^8.0.0",
"@commitlint/config-conventional": "^8.0.0",
"@webpack-contrib/defaults": "^5.0.0",
"@webpack-contrib/eslint-config-webpack": "^3.0.0",
"babel-jest": "^24.8.0",
"commitlint-azure-pipelines-cli": "^1.0.2",
"cross-env": "^5.2.0",
"del": "^5.0.0",
"del-cli": "^2.0.0",
"eslint": "^6.0.1",
"eslint-config-prettier": "^6.0.0",
"eslint-plugin-import": "^2.0.0",
"husky": "^3.0.0",
"jest": "^24.8.0",
"jest-junit": "^6.4.0",
"lint-staged": "^9.2.0",
"npm-run-all": "^4.1.5",
"prettier": "^1.0.0",
"standard-version": "^6.0.1"
},
"engines": {
"node": ">= 8.9.0"
},
"files": [
"dist"
],
"homepage": "https://github.com/webpack-contrib/schema-utils",
"keywords": [
"webpack"
],
"license": "MIT",
"main": "dist/index.js",
"name": "@develar/schema-utils",
"repository": {
"type": "git",
"url": "git+https://github.com/webpack-contrib/schema-utils.git"
},
"scripts": {
"build": "cross-env NODE_ENV=production babel src -d dist --ignore \"src/**/*.test.js\" --copy-files",
"clean": "del-cli dist",
"commitlint": "commitlint --from=master",
"defaults": "webpack-defaults",
"lint": "npm-run-all -l -p \"lint:**\"",
"lint:js": "eslint --cache src test",
"lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css}\" --list-different",
"prebuild": "npm run clean",
"prepare": "npm run build",
"pretest": "npm run lint",
"release": "standard-version",
"security": "npm audit",
"start": "npm run build -- -w",
"test": "cross-env NODE_ENV=test npm run test:coverage",
"test:coverage": "cross-env NODE_ENV=test jest --collectCoverageFrom=\"src/**/*.js\" --coverage",
"test:only": "cross-env NODE_ENV=test jest",
"test:watch": "cross-env NODE_ENV=test jest --watch"
},
"version": "2.1.0"
}