@alexlit/lint-kit 175.0.0 → 176.0.1

package/packages/config-eslint/node_modules/json-schema-traverse/README.md

@@ -1,83 +0,0 @@
-# json-schema-traverse
-Traverse JSON Schema passing each schema object to callback
-
-[![Build Status](https://travis-ci.org/epoberezkin/json-schema-traverse.svg?branch=master)](https://travis-ci.org/epoberezkin/json-schema-traverse)
-[![npm version](https://badge.fury.io/js/json-schema-traverse.svg)](https://www.npmjs.com/package/json-schema-traverse)
-[![Coverage Status](https://coveralls.io/repos/github/epoberezkin/json-schema-traverse/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/json-schema-traverse?branch=master)
-
-
-## Install
-
-```
-npm install json-schema-traverse
-```
-
-
-## Usage
-
-```javascript
-const traverse = require('json-schema-traverse');
-const schema = {
-  properties: {
-    foo: {type: 'string'},
-    bar: {type: 'integer'}
-  }
-};
-
-traverse(schema, {cb});
-// cb is called 3 times with:
-// 1. root schema
-// 2. {type: 'string'}
-// 3. {type: 'integer'}
-
-// Or:
-
-traverse(schema, {cb: {pre, post}});
-// pre is called 3 times with:
-// 1. root schema
-// 2. {type: 'string'}
-// 3. {type: 'integer'}
-//
-// post is called 3 times with:
-// 1. {type: 'string'}
-// 2. {type: 'integer'}
-// 3. root schema
-
-```
-
-Callback function `cb` is called for each schema object (not including draft-06 boolean schemas), including the root schema, in pre-order traversal. Schema references ($ref) are not resolved, they are passed as is.  Alternatively, you can pass a `{pre, post}` object as `cb`, and then `pre` will be called before traversing child elements, and `post` will be called after all child elements have been traversed.
-
-Callback is passed these parameters:
-
-- _schema_: the current schema object
-- _JSON pointer_: from the root schema to the current schema object
-- _root schema_: the schema passed to `traverse` object
-- _parent JSON pointer_: from the root schema to the parent schema object (see below)
-- _parent keyword_: the keyword inside which this schema appears (e.g. `properties`, `anyOf`, etc.)
-- _parent schema_: not necessarily parent object/array; in the example above the parent schema for `{type: 'string'}` is the root schema
-- _index/property_: index or property name in the array/object containing multiple schemas; in the example above for `{type: 'string'}` the property name is `'foo'`
-
-
-## Traverse objects in all unknown keywords
-
-```javascript
-const traverse = require('json-schema-traverse');
-const schema = {
-  mySchema: {
-    minimum: 1,
-    maximum: 2
-  }
-};
-
-traverse(schema, {allKeys: true, cb});
-// cb is called 2 times with:
-// 1. root schema
-// 2. mySchema
-```
-
-Without option `allKeys: true` callback will be called only with root schema.
-
-
-## License
-
-[MIT](https://github.com/epoberezkin/json-schema-traverse/blob/master/LICENSE)

package/packages/config-eslint/node_modules/json-schema-traverse/index.js

@@ -1,89 +0,0 @@
-'use strict';
-
-var traverse = module.exports = function (schema, opts, cb) {
-  // Legacy support for v0.3.1 and earlier.
-  if (typeof opts == 'function') {
-    cb = opts;
-    opts = {};
-  }
-
-  cb = opts.cb || cb;
-  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};
-  var post = cb.post || function() {};
-
-  _traverse(opts, pre, post, schema, '', schema);
-};
-
-
-traverse.keywords = {
-  additionalItems: true,
-  items: true,
-  contains: true,
-  additionalProperties: true,
-  propertyNames: true,
-  not: true
-};
-
-traverse.arrayKeywords = {
-  items: true,
-  allOf: true,
-  anyOf: true,
-  oneOf: true
-};
-
-traverse.propsKeywords = {
-  definitions: true,
-  properties: true,
-  patternProperties: true,
-  dependencies: true
-};
-
-traverse.skipKeywords = {
-  default: true,
-  enum: true,
-  const: true,
-  required: true,
-  maximum: true,
-  minimum: true,
-  exclusiveMaximum: true,
-  exclusiveMinimum: true,
-  multipleOf: true,
-  maxLength: true,
-  minLength: true,
-  pattern: true,
-  format: true,
-  maxItems: true,
-  minItems: true,
-  uniqueItems: true,
-  maxProperties: true,
-  minProperties: true
-};
-
-
-function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {
-    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-    for (var key in schema) {
-      var sch = schema[key];
-      if (Array.isArray(sch)) {
-        if (key in traverse.arrayKeywords) {
-          for (var i=0; i<sch.length; i++)
-            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);
-        }
-      } else if (key in traverse.propsKeywords) {
-        if (sch && typeof sch == 'object') {
-          for (var prop in sch)
-            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
-        }
-      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {
-        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);
-      }
-    }
-    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-  }
-}
-
-
-function escapeJsonPtr(str) {
-  return str.replace(/~/g, '~0').replace(/\//g, '~1');
-}

package/packages/config-eslint/node_modules/json-schema-traverse/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "json-schema-traverse",
-  "version": "0.4.1",
-  "description": "Traverse JSON Schema passing each schema object to callback",
-  "main": "index.js",
-  "scripts": {
-    "eslint": "eslint index.js spec",
-    "test-spec": "mocha spec -R spec",
-    "test": "npm run eslint && nyc npm run test-spec"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/epoberezkin/json-schema-traverse.git"
-  },
-  "keywords": [
-    "JSON-Schema",
-    "traverse",
-    "iterate"
-  ],
-  "author": "Evgeny Poberezkin",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/epoberezkin/json-schema-traverse/issues"
-  },
-  "homepage": "https://github.com/epoberezkin/json-schema-traverse#readme",
-  "devDependencies": {
-    "coveralls": "^2.13.1",
-    "eslint": "^3.19.0",
-    "mocha": "^3.4.2",
-    "nyc": "^11.0.2",
-    "pre-commit": "^1.2.2"
-  },
-  "nyc": {
-    "exclude": [
-      "**/spec/**",
-      "node_modules"
-    ],
-    "reporter": [
-      "lcov",
-      "text-summary"
-    ]
-  }
-}

package/packages/config-eslint/node_modules/json-schema-traverse/spec/.eslintrc.yml

@@ -1,6 +0,0 @@
-parserOptions:
-  ecmaVersion: 6
-globals:
-  beforeEach: false
-  describe: false
-  it: false

package/packages/config-eslint/node_modules/json-schema-traverse/spec/fixtures/schema.js

@@ -1,125 +0,0 @@
-'use strict';
-
-var schema = {
-  additionalItems: subschema('additionalItems'),
-  items: subschema('items'),
-  contains: subschema('contains'),
-  additionalProperties: subschema('additionalProperties'),
-  propertyNames: subschema('propertyNames'),
-  not: subschema('not'),
-  allOf: [
-    subschema('allOf_0'),
-    subschema('allOf_1'),
-    {
-      items: [
-        subschema('items_0'),
-        subschema('items_1'),
-      ]
-    }
-  ],
-  anyOf: [
-    subschema('anyOf_0'),
-    subschema('anyOf_1'),
-  ],
-  oneOf: [
-    subschema('oneOf_0'),
-    subschema('oneOf_1'),
-  ],
-  definitions: {
-    foo: subschema('definitions_foo'),
-    bar: subschema('definitions_bar'),
-  },
-  properties: {
-    foo: subschema('properties_foo'),
-    bar: subschema('properties_bar'),
-  },
-  patternProperties: {
-    foo: subschema('patternProperties_foo'),
-    bar: subschema('patternProperties_bar'),
-  },
-  dependencies: {
-    foo: subschema('dependencies_foo'),
-    bar: subschema('dependencies_bar'),
-  },
-  required: ['foo', 'bar']
-};
-
-
-function subschema(keyword) {
-  var sch = {
-    properties: {},
-    additionalProperties: false,
-    additionalItems: false,
-    anyOf: [
-      {format: 'email'},
-      {format: 'hostname'}
-    ]
-  };
-  sch.properties['foo_' + keyword] = {title: 'foo'};
-  sch.properties['bar_' + keyword] = {title: 'bar'};
-  return sch;
-}
-
-
-module.exports = {
-  schema: schema,
-
-  // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-  expectedCalls: [[schema, '', schema, undefined, undefined, undefined, undefined]]
-    .concat(expectedCalls('additionalItems'))
-    .concat(expectedCalls('items'))
-    .concat(expectedCalls('contains'))
-    .concat(expectedCalls('additionalProperties'))
-    .concat(expectedCalls('propertyNames'))
-    .concat(expectedCalls('not'))
-    .concat(expectedCallsChild('allOf', 0))
-    .concat(expectedCallsChild('allOf', 1))
-    .concat([
-      [schema.allOf[2], '/allOf/2', schema, '', 'allOf', schema, 2],
-      [schema.allOf[2].items[0], '/allOf/2/items/0', schema, '/allOf/2', 'items', schema.allOf[2], 0],
-      [schema.allOf[2].items[0].properties.foo_items_0, '/allOf/2/items/0/properties/foo_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'foo_items_0'],
-      [schema.allOf[2].items[0].properties.bar_items_0, '/allOf/2/items/0/properties/bar_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'bar_items_0'],
-      [schema.allOf[2].items[0].anyOf[0], '/allOf/2/items/0/anyOf/0', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 0],
-      [schema.allOf[2].items[0].anyOf[1], '/allOf/2/items/0/anyOf/1', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 1],
-
-      [schema.allOf[2].items[1], '/allOf/2/items/1', schema, '/allOf/2', 'items', schema.allOf[2], 1],
-      [schema.allOf[2].items[1].properties.foo_items_1, '/allOf/2/items/1/properties/foo_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'foo_items_1'],
-      [schema.allOf[2].items[1].properties.bar_items_1, '/allOf/2/items/1/properties/bar_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'bar_items_1'],
-      [schema.allOf[2].items[1].anyOf[0], '/allOf/2/items/1/anyOf/0', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 0],
-      [schema.allOf[2].items[1].anyOf[1], '/allOf/2/items/1/anyOf/1', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 1]
-    ])
-    .concat(expectedCallsChild('anyOf', 0))
-    .concat(expectedCallsChild('anyOf', 1))
-    .concat(expectedCallsChild('oneOf', 0))
-    .concat(expectedCallsChild('oneOf', 1))
-    .concat(expectedCallsChild('definitions', 'foo'))
-    .concat(expectedCallsChild('definitions', 'bar'))
-    .concat(expectedCallsChild('properties', 'foo'))
-    .concat(expectedCallsChild('properties', 'bar'))
-    .concat(expectedCallsChild('patternProperties', 'foo'))
-    .concat(expectedCallsChild('patternProperties', 'bar'))
-    .concat(expectedCallsChild('dependencies', 'foo'))
-    .concat(expectedCallsChild('dependencies', 'bar'))
-};
-
-
-function expectedCalls(keyword) {
-  return [
-    [schema[keyword], `/${keyword}`, schema, '', keyword, schema, undefined],
-    [schema[keyword].properties[`foo_${keyword}`], `/${keyword}/properties/foo_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `foo_${keyword}`],
-    [schema[keyword].properties[`bar_${keyword}`], `/${keyword}/properties/bar_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `bar_${keyword}`],
-    [schema[keyword].anyOf[0], `/${keyword}/anyOf/0`, schema, `/${keyword}`, 'anyOf', schema[keyword], 0],
-    [schema[keyword].anyOf[1], `/${keyword}/anyOf/1`, schema, `/${keyword}`, 'anyOf', schema[keyword], 1]
-  ];
-}
-
-
-function expectedCallsChild(keyword, i) {
-  return [
-    [schema[keyword][i], `/${keyword}/${i}`, schema, '', keyword, schema, i],
-    [schema[keyword][i].properties[`foo_${keyword}_${i}`], `/${keyword}/${i}/properties/foo_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `foo_${keyword}_${i}`],
-    [schema[keyword][i].properties[`bar_${keyword}_${i}`], `/${keyword}/${i}/properties/bar_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `bar_${keyword}_${i}`],
-    [schema[keyword][i].anyOf[0], `/${keyword}/${i}/anyOf/0`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 0],
-    [schema[keyword][i].anyOf[1], `/${keyword}/${i}/anyOf/1`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 1]
-  ];
-}

package/packages/config-eslint/node_modules/json-schema-traverse/spec/index.spec.js

@@ -1,171 +0,0 @@
-'use strict';
-
-var traverse = require('../index');
-var assert = require('assert');
-
-describe('json-schema-traverse', function() {
-  var calls;
-
-  beforeEach(function() {
-    calls = [];
-  });
-
-  it('should traverse all keywords containing schemas recursively', function() {
-    var schema = require('./fixtures/schema').schema;
-    var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-    traverse(schema, {cb: callback});
-    assert.deepStrictEqual(calls, expectedCalls);
-  });
-
-  describe('Legacy v0.3.1 API', function() {
-    it('should traverse all keywords containing schemas recursively', function() {
-      var schema = require('./fixtures/schema').schema;
-      var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-      traverse(schema, callback);
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should work when an options object is provided', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var schema = require('./fixtures/schema').schema;
-      var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-      traverse(schema, {}, callback);
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-
-  describe('allKeys option', function() {
-    var schema = {
-      someObject: {
-        minimum: 1,
-        maximum: 2
-      }
-    };
-
-    it('should traverse objects with allKeys: true option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined],
-        [schema.someObject, '/someObject', schema, '', 'someObject', schema, undefined]
-      ];
-
-      traverse(schema, {allKeys: true, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT traverse objects with allKeys: false option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined]
-      ];
-
-      traverse(schema, {allKeys: false, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT traverse objects without allKeys option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined]
-      ];
-
-      traverse(schema, {cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT travers objects in standard keywords which value is not a schema', function() {
-      var schema2 = {
-        const: {foo: 'bar'},
-        enum: ['a', 'b'],
-        required: ['foo'],
-        another: {
-
-        },
-        patternProperties: {}, // will not traverse - no properties
-        dependencies: true, // will not traverse - invalid
-        properties: {
-          smaller: {
-            type: 'number'
-          },
-          larger: {
-            type: 'number',
-            minimum: {$data: '1/smaller'}
-          }
-        }
-      };
-
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema2, '', schema2, undefined, undefined, undefined, undefined],
-        [schema2.another, '/another', schema2, '', 'another', schema2, undefined],
-        [schema2.properties.smaller, '/properties/smaller', schema2, '', 'properties', schema2, 'smaller'],
-        [schema2.properties.larger, '/properties/larger', schema2, '', 'properties', schema2, 'larger'],
-      ];
-
-      traverse(schema2, {allKeys: true, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-  describe('pre and post', function() {
-    var schema = {
-      type: 'object',
-      properties: {
-        name: {type: 'string'},
-        age: {type: 'number'}
-      }
-    };
-
-    it('should traverse schema in pre-order', function() {
-      traverse(schema, {cb: {pre}});
-      var expectedCalls = [
-        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
-        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should traverse schema in post-order', function() {
-      traverse(schema, {cb: {post}});
-      var expectedCalls = [
-        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should traverse schema in pre- and post-order at the same time', function() {
-      traverse(schema, {cb: {pre, post}});
-      var expectedCalls = [
-        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
-        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-  function callback() {
-    calls.push(Array.prototype.slice.call(arguments));
-  }
-
-  function pre() {
-    calls.push(['pre'].concat(Array.prototype.slice.call(arguments)));
-  }
-
-  function post() {
-    calls.push(['post'].concat(Array.prototype.slice.call(arguments)));
-  }
-});

package/packages/config-eslint/node_modules/minimatch/LICENSE.md

@@ -1,55 +0,0 @@
-# Blue Oak Model License
-
-Version 1.0.0
-
-## Purpose
-
-This license gives everyone as much permission to work with
-this software as possible, while protecting contributors
-from liability.
-
-## Acceptance
-
-In order to receive this license, you must agree to its
-rules. The rules of this license are both obligations
-under that agreement and conditions to your license.
-You must not do anything with this software that triggers
-a rule that you cannot or will not follow.
-
-## Copyright
-
-Each contributor licenses you to do everything with this
-software that would otherwise infringe that contributor's
-copyright in it.
-
-## Notices
-
-You must ensure that everyone who gets a copy of
-any part of this software from you, with or without
-changes, also gets the text of this license or a link to
-<https://blueoakcouncil.org/license/1.0.0>.
-
-## Excuse
-
-If anyone notifies you in writing that you have not
-complied with [Notices](#notices), you can keep your
-license by taking all practical steps to comply within 30
-days after the notice. If you do not do so, your license
-ends immediately.
-
-## Patent
-
-Each contributor licenses you to do everything with this
-software that would otherwise infringe any patent claims
-they can license or become able to license.
-
-## Reliability
-
-No contributor can revoke this license.
-
-## No Liability
-
-**_As far as the law allows, this software comes as is,
-without any warranty or condition, and no contributor
-will be liable to anyone for any damages related to this
-software or this license, under any kind of legal claim._**