web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/contains.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var contains = require('../../../../../_virtual/contains.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+
+var hasRequiredContains;
+function requireContains() {
+  if (hasRequiredContains) return contains.__exports;
+  hasRequiredContains = 1;
+  Object.defineProperty(contains.__exports, "__esModule", {
+    value: true
+  });
+  const codegen_1 = index.__require();
+  const util_1 = util.__require();
+  const error = {
+    message: _ref => {
+      let {
+        params: {
+          min,
+          max
+        }
+      } = _ref;
+      return max === undefined ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`;
+    },
+    params: _ref2 => {
+      let {
+        params: {
+          min,
+          max
+        }
+      } = _ref2;
+      return max === undefined ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`;
+    }
+  };
+  const def = {
+    keyword: "contains",
+    type: "array",
+    schemaType: ["object", "boolean"],
+    before: "uniqueItems",
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const {
+        gen,
+        schema,
+        parentSchema,
+        data,
+        it
+      } = cxt;
+      let min;
+      let max;
+      const {
+        minContains,
+        maxContains
+      } = parentSchema;
+      if (it.opts.next) {
+        min = minContains === undefined ? 1 : minContains;
+        max = maxContains;
+      } else {
+        min = 1;
+      }
+      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+      cxt.setParams({
+        min,
+        max
+      });
+      if (max === undefined && min === 0) {
+        (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
+        return;
+      }
+      if (max !== undefined && min > max) {
+        (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
+        cxt.fail();
+        return;
+      }
+      if ((0, util_1.alwaysValidSchema)(it, schema)) {
+        let cond = (0, codegen_1._)`${len} >= ${min}`;
+        if (max !== undefined) cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
+        cxt.pass(cond);
+        return;
+      }
+      it.items = true;
+      const valid = gen.name("valid");
+      if (max === undefined && min === 1) {
+        validateItems(valid, () => gen.if(valid, () => gen.break()));
+      } else if (min === 0) {
+        gen.let(valid, true);
+        if (max !== undefined) gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
+      } else {
+        gen.let(valid, false);
+        validateItemsWithCount();
+      }
+      cxt.result(valid, () => cxt.reset());
+      function validateItemsWithCount() {
+        const schValid = gen.name("_valid");
+        const count = gen.let("count", 0);
+        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
+      }
+      function validateItems(_valid, block) {
+        gen.forRange("i", 0, len, i => {
+          cxt.subschema({
+            keyword: "contains",
+            dataProp: i,
+            dataPropType: util_1.Type.Num,
+            compositeRule: true
+          }, _valid);
+          block();
+        });
+      }
+      function checkLimits(count) {
+        gen.code((0, codegen_1._)`${count}++`);
+        if (max === undefined) {
+          gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
+        } else {
+          gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
+          if (min === 1) gen.assign(valid, true);else gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
+        }
+      }
+    }
+  };
+  contains.__exports.default = def;
+  return contains.__exports;
+}
+
+exports.__require = requireContains;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/dependencies.js

@@ -0,0 +1,132 @@
+'use strict';
+
+var dependencies = require('../../../../../_virtual/dependencies.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+var code = require('../code.js');
+
+var hasRequiredDependencies;
+function requireDependencies() {
+  if (hasRequiredDependencies) return dependencies.__exports;
+  hasRequiredDependencies = 1;
+  (function (exports) {
+
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
+    const codegen_1 = index.__require();
+    const util_1 = util.__require();
+    const code_1 = code.__require();
+    exports.error = {
+      message: _ref => {
+        let {
+          params: {
+            property,
+            depsCount,
+            deps
+          }
+        } = _ref;
+        const property_ies = depsCount === 1 ? "property" : "properties";
+        return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
+      },
+      params: _ref2 => {
+        let {
+          params: {
+            property,
+            depsCount,
+            deps,
+            missingProperty
+          }
+        } = _ref2;
+        return (0, codegen_1._)`{property: ${property},
+    missingProperty: ${missingProperty},
+    depsCount: ${depsCount},
+    deps: ${deps}}`;
+      } // TODO change to reference
+    };
+    const def = {
+      keyword: "dependencies",
+      type: "object",
+      schemaType: "object",
+      error: exports.error,
+      code(cxt) {
+        const [propDeps, schDeps] = splitDependencies(cxt);
+        validatePropertyDeps(cxt, propDeps);
+        validateSchemaDeps(cxt, schDeps);
+      }
+    };
+    function splitDependencies(_ref3) {
+      let {
+        schema
+      } = _ref3;
+      const propertyDeps = {};
+      const schemaDeps = {};
+      for (const key in schema) {
+        if (key === "__proto__") continue;
+        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
+        deps[key] = schema[key];
+      }
+      return [propertyDeps, schemaDeps];
+    }
+    function validatePropertyDeps(cxt) {
+      let propertyDeps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cxt.schema;
+      const {
+        gen,
+        data,
+        it
+      } = cxt;
+      if (Object.keys(propertyDeps).length === 0) return;
+      const missing = gen.let("missing");
+      for (const prop in propertyDeps) {
+        const deps = propertyDeps[prop];
+        if (deps.length === 0) continue;
+        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
+        cxt.setParams({
+          property: prop,
+          depsCount: deps.length,
+          deps: deps.join(", ")
+        });
+        if (it.allErrors) {
+          gen.if(hasProperty, () => {
+            for (const depProp of deps) {
+              (0, code_1.checkReportMissingProp)(cxt, depProp);
+            }
+          });
+        } else {
+          gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
+          (0, code_1.reportMissingProp)(cxt, missing);
+          gen.else();
+        }
+      }
+    }
+    exports.validatePropertyDeps = validatePropertyDeps;
+    function validateSchemaDeps(cxt) {
+      let schemaDeps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cxt.schema;
+      const {
+        gen,
+        data,
+        keyword,
+        it
+      } = cxt;
+      const valid = gen.name("valid");
+      for (const prop in schemaDeps) {
+        if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
+        gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
+          const schCxt = cxt.subschema({
+            keyword,
+            schemaProp: prop
+          }, valid);
+          cxt.mergeValidEvaluated(schCxt, valid);
+        }, () => gen.var(valid, true) // TODO var
+        );
+        cxt.ok(valid);
+      }
+    }
+    exports.validateSchemaDeps = validateSchemaDeps;
+    exports.default = def;
+  })(dependencies.__exports);
+  return dependencies.__exports;
+}
+
+exports.__require = requireDependencies;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/if.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var _if = require('../../../../../_virtual/if.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+
+var hasRequired_if;
+function require_if() {
+  if (hasRequired_if) return _if.__exports;
+  hasRequired_if = 1;
+  Object.defineProperty(_if.__exports, "__esModule", {
+    value: true
+  });
+  const codegen_1 = index.__require();
+  const util_1 = util.__require();
+  const error = {
+    message: _ref => {
+      let {
+        params
+      } = _ref;
+      return (0, codegen_1.str)`must match "${params.ifClause}" schema`;
+    },
+    params: _ref2 => {
+      let {
+        params
+      } = _ref2;
+      return (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`;
+    }
+  };
+  const def = {
+    keyword: "if",
+    schemaType: ["object", "boolean"],
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const {
+        gen,
+        parentSchema,
+        it
+      } = cxt;
+      if (parentSchema.then === undefined && parentSchema.else === undefined) {
+        (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
+      }
+      const hasThen = hasSchema(it, "then");
+      const hasElse = hasSchema(it, "else");
+      if (!hasThen && !hasElse) return;
+      const valid = gen.let("valid", true);
+      const schValid = gen.name("_valid");
+      validateIf();
+      cxt.reset();
+      if (hasThen && hasElse) {
+        const ifClause = gen.let("ifClause");
+        cxt.setParams({
+          ifClause
+        });
+        gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
+      } else if (hasThen) {
+        gen.if(schValid, validateClause("then"));
+      } else {
+        gen.if((0, codegen_1.not)(schValid), validateClause("else"));
+      }
+      cxt.pass(valid, () => cxt.error(true));
+      function validateIf() {
+        const schCxt = cxt.subschema({
+          keyword: "if",
+          compositeRule: true,
+          createErrors: false,
+          allErrors: false
+        }, schValid);
+        cxt.mergeEvaluated(schCxt);
+      }
+      function validateClause(keyword, ifClause) {
+        return () => {
+          const schCxt = cxt.subschema({
+            keyword
+          }, schValid);
+          gen.assign(valid, schValid);
+          cxt.mergeValidEvaluated(schCxt, valid);
+          if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);else cxt.setParams({
+            ifClause: keyword
+          });
+        };
+      }
+    }
+  };
+  function hasSchema(it, keyword) {
+    const schema = it.schema[keyword];
+    return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
+  }
+  _if.__exports.default = def;
+  return _if.__exports;
+}
+
+exports.__require = require_if;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/index.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var index = require('../../../../../_virtual/index21.js');
+var additionalItems = require('./additionalItems.js');
+var prefixItems = require('./prefixItems.js');
+var items = require('./items.js');
+var items2020 = require('./items2020.js');
+var contains = require('./contains.js');
+var dependencies = require('./dependencies.js');
+var propertyNames = require('./propertyNames.js');
+var additionalProperties = require('./additionalProperties.js');
+var properties = require('./properties.js');
+var patternProperties = require('./patternProperties.js');
+var not = require('./not.js');
+var anyOf = require('./anyOf.js');
+var oneOf = require('./oneOf.js');
+var allOf = require('./allOf.js');
+var _if = require('./if.js');
+var thenElse = require('./thenElse.js');
+
+var hasRequiredApplicator;
+function requireApplicator() {
+  if (hasRequiredApplicator) return index.__exports;
+  hasRequiredApplicator = 1;
+  Object.defineProperty(index.__exports, "__esModule", {
+    value: true
+  });
+  const additionalItems_1 = additionalItems.__require();
+  const prefixItems_1 = prefixItems.__require();
+  const items_1 = items.__require();
+  const items2020_1 = items2020.__require();
+  const contains_1 = contains.__require();
+  const dependencies_1 = dependencies.__require();
+  const propertyNames_1 = propertyNames.__require();
+  const additionalProperties_1 = additionalProperties.__require();
+  const properties_1 = properties.__require();
+  const patternProperties_1 = patternProperties.__require();
+  const not_1 = not.__require();
+  const anyOf_1 = anyOf.__require();
+  const oneOf_1 = oneOf.__require();
+  const allOf_1 = allOf.__require();
+  const if_1 = _if.__require();
+  const thenElse_1 = thenElse.__require();
+  function getApplicator() {
+    let draft2020 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const applicator = [
+    // any
+    not_1.default, anyOf_1.default, oneOf_1.default, allOf_1.default, if_1.default, thenElse_1.default,
+    // object
+    propertyNames_1.default, additionalProperties_1.default, dependencies_1.default, properties_1.default, patternProperties_1.default];
+    // array
+    if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);else applicator.push(additionalItems_1.default, items_1.default);
+    applicator.push(contains_1.default);
+    return applicator;
+  }
+  index.__exports.default = getApplicator;
+  return index.__exports;
+}
+
+exports.__require = requireApplicator;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/items.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var items = require('../../../../../_virtual/items.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+var code = require('../code.js');
+
+var hasRequiredItems;
+function requireItems() {
+  if (hasRequiredItems) return items.__exports;
+  hasRequiredItems = 1;
+  Object.defineProperty(items.__exports, "__esModule", {
+    value: true
+  });
+  items.__exports.validateTuple = void 0;
+  const codegen_1 = index.__require();
+  const util_1 = util.__require();
+  const code_1 = code.__require();
+  const def = {
+    keyword: "items",
+    type: "array",
+    schemaType: ["object", "array", "boolean"],
+    before: "uniqueItems",
+    code(cxt) {
+      const {
+        schema,
+        it
+      } = cxt;
+      if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema);
+      it.items = true;
+      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
+      cxt.ok((0, code_1.validateArray)(cxt));
+    }
+  };
+  function validateTuple(cxt, extraItems) {
+    let schArr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : cxt.schema;
+    const {
+      gen,
+      parentSchema,
+      data,
+      keyword,
+      it
+    } = cxt;
+    checkStrictTuple(parentSchema);
+    if (it.opts.unevaluated && schArr.length && it.items !== true) {
+      it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
+    }
+    const valid = gen.name("valid");
+    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+    schArr.forEach((sch, i) => {
+      if ((0, util_1.alwaysValidSchema)(it, sch)) return;
+      gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
+        keyword,
+        schemaProp: i,
+        dataProp: i
+      }, valid));
+      cxt.ok(valid);
+    });
+    function checkStrictTuple(sch) {
+      const {
+        opts,
+        errSchemaPath
+      } = it;
+      const l = schArr.length;
+      const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
+      if (opts.strictTuples && !fullTuple) {
+        const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
+        (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
+      }
+    }
+  }
+  items.__exports.validateTuple = validateTuple;
+  items.__exports.default = def;
+  return items.__exports;
+}
+
+exports.__require = requireItems;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/items2020.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var items2020 = require('../../../../../_virtual/items2020.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+var code = require('../code.js');
+var additionalItems = require('./additionalItems.js');
+
+var hasRequiredItems2020;
+function requireItems2020() {
+  if (hasRequiredItems2020) return items2020.__exports;
+  hasRequiredItems2020 = 1;
+  Object.defineProperty(items2020.__exports, "__esModule", {
+    value: true
+  });
+  const codegen_1 = index.__require();
+  const util_1 = util.__require();
+  const code_1 = code.__require();
+  const additionalItems_1 = additionalItems.__require();
+  const error = {
+    message: _ref => {
+      let {
+        params: {
+          len
+        }
+      } = _ref;
+      return (0, codegen_1.str)`must NOT have more than ${len} items`;
+    },
+    params: _ref2 => {
+      let {
+        params: {
+          len
+        }
+      } = _ref2;
+      return (0, codegen_1._)`{limit: ${len}}`;
+    }
+  };
+  const def = {
+    keyword: "items",
+    type: "array",
+    schemaType: ["object", "boolean"],
+    before: "uniqueItems",
+    error,
+    code(cxt) {
+      const {
+        schema,
+        parentSchema,
+        it
+      } = cxt;
+      const {
+        prefixItems
+      } = parentSchema;
+      it.items = true;
+      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
+      if (prefixItems) (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);else cxt.ok((0, code_1.validateArray)(cxt));
+    }
+  };
+  items2020.__exports.default = def;
+  return items2020.__exports;
+}
+
+exports.__require = requireItems2020;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/not.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var not = require('../../../../../_virtual/not.js');
+var util = require('../../compile/util.js');
+
+var hasRequiredNot;
+function requireNot() {
+  if (hasRequiredNot) return not.__exports;
+  hasRequiredNot = 1;
+  Object.defineProperty(not.__exports, "__esModule", {
+    value: true
+  });
+  const util_1 = util.__require();
+  const def = {
+    keyword: "not",
+    schemaType: ["object", "boolean"],
+    trackErrors: true,
+    code(cxt) {
+      const {
+        gen,
+        schema,
+        it
+      } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema)) {
+        cxt.fail();
+        return;
+      }
+      const valid = gen.name("valid");
+      cxt.subschema({
+        keyword: "not",
+        compositeRule: true,
+        createErrors: false,
+        allErrors: false
+      }, valid);
+      cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
+    },
+    error: {
+      message: "must NOT be valid"
+    }
+  };
+  not.__exports.default = def;
+  return not.__exports;
+}
+
+exports.__require = requireNot;

package/dist/cjs/node_modules/ajv/dist/vocabularies/applicator/oneOf.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var oneOf = require('../../../../../_virtual/oneOf.js');
+var index = require('../../compile/codegen/index.js');
+var util = require('../../compile/util.js');
+
+var hasRequiredOneOf;
+function requireOneOf() {
+  if (hasRequiredOneOf) return oneOf.__exports;
+  hasRequiredOneOf = 1;
+  Object.defineProperty(oneOf.__exports, "__esModule", {
+    value: true
+  });
+  const codegen_1 = index.__require();
+  const util_1 = util.__require();
+  const error = {
+    message: "must match exactly one schema in oneOf",
+    params: _ref => {
+      let {
+        params
+      } = _ref;
+      return (0, codegen_1._)`{passingSchemas: ${params.passing}}`;
+    }
+  };
+  const def = {
+    keyword: "oneOf",
+    schemaType: "array",
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const {
+        gen,
+        schema,
+        parentSchema,
+        it
+      } = cxt;
+      /* istanbul ignore if */
+      if (!Array.isArray(schema)) throw new Error("ajv implementation error");
+      if (it.opts.discriminator && parentSchema.discriminator) return;
+      const schArr = schema;
+      const valid = gen.let("valid", false);
+      const passing = gen.let("passing", null);
+      const schValid = gen.name("_valid");
+      cxt.setParams({
+        passing
+      });
+      // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas
+      gen.block(validateOneOf);
+      cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
+      function validateOneOf() {
+        schArr.forEach((sch, i) => {
+          let schCxt;
+          if ((0, util_1.alwaysValidSchema)(it, sch)) {
+            gen.var(schValid, true);
+          } else {
+            schCxt = cxt.subschema({
+              keyword: "oneOf",
+              schemaProp: i,
+              compositeRule: true
+            }, schValid);
+          }
+          if (i > 0) {
+            gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
+          }
+          gen.if(schValid, () => {
+            gen.assign(valid, true);
+            gen.assign(passing, i);
+            if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
+          });
+        });
+      }
+    }
+  };
+  oneOf.__exports.default = def;
+  return oneOf.__exports;
+}
+
+exports.__require = requireOneOf;