z-schema 7.0.0 → 7.0.6

package/src/SchemaCompilation.ts

@@ -1,293 +0,0 @@
-import { Report } from './Report.js';
-import { getSchemaByUri, checkCacheForUri, cacheSchemaByUri, removeFromCacheByUri } from './SchemaCache.js';
-import * as Utils from './Utils.js';
-
-function mergeReference(scope, ref) {
-  if (Utils.isAbsoluteUri(ref)) {
-    return ref;
-  }
-
-  let joinedScope = scope.join('');
-  const isScopeAbsolute = Utils.isAbsoluteUri(joinedScope);
-  const isScopeRelative = Utils.isRelativeUri(joinedScope);
-  const isRefRelative = Utils.isRelativeUri(ref);
-  let toRemove;
-
-  if (isScopeAbsolute && isRefRelative) {
-    toRemove = joinedScope.match(/\/[^/]*$/);
-    if (toRemove) {
-      joinedScope = joinedScope.slice(0, toRemove.index + 1);
-    }
-  } else if (isScopeRelative && isRefRelative) {
-    joinedScope = '';
-  } else {
-    toRemove = joinedScope.match(/[^#/]+$/);
-    if (toRemove) {
-      joinedScope = joinedScope.slice(0, toRemove.index);
-    }
-  }
-
-  let res = joinedScope + ref;
-  res = res.replace(/##/, '#');
-  return res;
-}
-
-function collectReferences(obj, results, scope, path) {
-  results = results || [];
-  scope = scope || [];
-  path = path || [];
-
-  if (typeof obj !== 'object' || obj === null) {
-    return results;
-  }
-
-  if (typeof obj.id === 'string') {
-    scope.push(obj.id);
-  }
-
-  if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
-    results.push({
-      ref: mergeReference(scope, obj.$ref),
-      key: '$ref',
-      obj: obj,
-      path: path.slice(0),
-    });
-  }
-  if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
-    results.push({
-      ref: mergeReference(scope, obj.$schema),
-      key: '$schema',
-      obj: obj,
-      path: path.slice(0),
-    });
-  }
-
-  let idx;
-  if (Array.isArray(obj)) {
-    idx = obj.length;
-    while (idx--) {
-      path.push(idx.toString());
-      collectReferences(obj[idx], results, scope, path);
-      path.pop();
-    }
-  } else {
-    const keys = Object.keys(obj);
-    idx = keys.length;
-    while (idx--) {
-      // do not recurse through resolved references and other z-schema props
-      if (keys[idx].indexOf('__$') === 0) {
-        continue;
-      }
-      path.push(keys[idx]);
-      collectReferences(obj[keys[idx]], results, scope, path);
-      path.pop();
-    }
-  }
-
-  if (typeof obj.id === 'string') {
-    scope.pop();
-  }
-
-  return results;
-}
-
-const compileArrayOfSchemasLoop = function (mainReport, arr) {
-  let idx = arr.length,
-    compiledCount = 0;
-
-  while (idx--) {
-    // try to compile each schema separately
-    const report = new Report(mainReport);
-    const isValid = compileSchema.call(this, report, arr[idx]);
-    if (isValid) {
-      compiledCount++;
-    }
-
-    // copy errors to report
-    mainReport.errors = mainReport.errors.concat(report.errors);
-  }
-
-  return compiledCount;
-};
-
-function findId(arr, id) {
-  let idx = arr.length;
-  while (idx--) {
-    if (arr[idx].id === id) {
-      return arr[idx];
-    }
-  }
-  return null;
-}
-
-const compileArrayOfSchemas = function (report, arr) {
-  let compiled = 0,
-    lastLoopCompiled;
-
-  do {
-    // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-    let idx = report.errors.length;
-    while (idx--) {
-      if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
-        report.errors.splice(idx, 1);
-      }
-    }
-
-    // remember how many were compiled in the last loop
-    lastLoopCompiled = compiled;
-
-    // count how many are compiled now
-    compiled = compileArrayOfSchemasLoop.call(this, report, arr);
-
-    // fix __$missingReferences if possible
-    idx = arr.length;
-    while (idx--) {
-      const sch = arr[idx];
-      if (sch.__$missingReferences) {
-        let idx2 = sch.__$missingReferences.length;
-        while (idx2--) {
-          const refObj = sch.__$missingReferences[idx2];
-          const response = findId(arr, refObj.ref);
-          if (response) {
-            // this might create circular references
-            refObj.obj['__' + refObj.key + 'Resolved'] = response;
-            // it's resolved now so delete it
-            sch.__$missingReferences.splice(idx2, 1);
-          }
-        }
-        if (sch.__$missingReferences.length === 0) {
-          delete sch.__$missingReferences;
-        }
-      }
-    }
-
-    // keep repeating if not all compiled and at least one more was compiled in the last loop
-  } while (compiled !== arr.length && compiled !== lastLoopCompiled);
-
-  return report.isValid();
-};
-
-export function compileSchema(report, schema) {
-  report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
-
-  // if schema is a string, assume it's a uri
-  if (typeof schema === 'string') {
-    const loadedSchema = getSchemaByUri.call(this, report, schema);
-    if (!loadedSchema) {
-      report.addError('SCHEMA_NOT_REACHABLE', [schema]);
-      return false;
-    }
-    schema = loadedSchema;
-  }
-
-  // if schema is an array, assume it's an array of schemas
-  if (Array.isArray(schema)) {
-    return compileArrayOfSchemas.call(this, report, schema);
-  }
-
-  // if we have an id than it should be cached already (if this instance has compiled it)
-  if (schema.__$compiled && schema.id && checkCacheForUri.call(this, schema.id) === false) {
-    schema.__$compiled = undefined;
-  }
-
-  // do not re-compile schemas
-  if (schema.__$compiled) {
-    return true;
-  }
-
-  if (schema.id && typeof schema.id === 'string') {
-    // add this to our schemaCache (before compilation in case we have references including id)
-    cacheSchemaByUri.call(this, schema.id, schema);
-  }
-
-  // this method can be called recursively, so we need to remember our root
-  let isRoot = false;
-  if (!report.rootSchema) {
-    report.rootSchema = schema;
-    isRoot = true;
-  }
-
-  // delete all __$missingReferences from previous compilation attempts
-  const isValidExceptReferences = report.isValid();
-  delete schema.__$missingReferences;
-
-  // collect all references that need to be resolved - $ref and $schema
-  const refs = collectReferences.call(this, schema);
-  let idx = refs.length;
-  while (idx--) {
-    // resolve all the collected references into __xxxResolved pointer
-    const refObj = refs[idx];
-    let response = getSchemaByUri.call(this, report, refObj.ref, schema);
-
-    // we can try to use custom schemaReader if available
-    if (!response) {
-      const schemaReader = this.getSchemaReader();
-      if (schemaReader) {
-        // it's supposed to return a valid schema
-        const s = schemaReader(refObj.ref);
-        if (s) {
-          // it needs to have the id
-          s.id = refObj.ref;
-          // try to compile the schema
-          const subreport = new Report(report);
-          if (!compileSchema.call(this, subreport, s)) {
-            // copy errors to report
-            report.errors = report.errors.concat(subreport.errors);
-          } else {
-            response = getSchemaByUri.call(this, report, refObj.ref, schema);
-          }
-        }
-      }
-    }
-
-    if (!response) {
-      const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
-      const isAbsolute = Utils.isAbsoluteUri(refObj.ref);
-      let isDownloaded = false;
-      const ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
-
-      if (isAbsolute) {
-        // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
-        // and set through setRemoteReference method
-        isDownloaded = checkCacheForUri.call(this, refObj.ref);
-      }
-
-      if (hasNotValid) {
-        // already has REMOTE_NOT_VALID error for this one
-      } else if (ignoreUnresolvableRemotes && isAbsolute) {
-        // ignoreUnresolvableRemotes is on and remote isAbsolute
-      } else if (isDownloaded) {
-        // remote is downloaded, so no UNRESOLVABLE_REFERENCE
-      } else {
-        Array.prototype.push.apply(report.path, refObj.path);
-        report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
-        report.path = report.path.slice(0, -refObj.path.length);
-
-        // pusblish unresolved references out
-        if (isValidExceptReferences) {
-          schema.__$missingReferences = schema.__$missingReferences || [];
-          schema.__$missingReferences.push(refObj);
-        }
-      }
-    }
-    // this might create circular references
-    refObj.obj['__' + refObj.key + 'Resolved'] = response;
-  }
-
-  const isValid = report.isValid();
-  if (isValid) {
-    schema.__$compiled = true;
-  } else {
-    if (schema.id && typeof schema.id === 'string') {
-      // remove this schema from schemaCache because it failed to compile
-      removeFromCacheByUri.call(this, schema.id);
-    }
-  }
-
-  // we don't need the root pointer anymore
-  if (isRoot) {
-    report.rootSchema = undefined;
-  }
-
-  return isValid;
-}

package/src/Utils.ts

@@ -1,286 +0,0 @@
-export const jsonSymbol = Symbol.for('z-schema/json');
-
-export const schemaSymbol = Symbol.for('z-schema/schema');
-
-/**
- * @param {object} obj
- *
- * @returns {string[]}
- */
-export function sortedKeys(obj) {
-  return Object.keys(obj).sort();
-}
-
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export function isAbsoluteUri(uri) {
-  return /^https?:\/\//.test(uri);
-}
-
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export function isRelativeUri(uri) {
-  // relative URIs that end with a hash sign, issue #56
-  return /.+#/.test(uri);
-}
-
-export function whatIs(what) {
-  const to = typeof what;
-
-  if (to === 'object') {
-    if (what === null) {
-      return 'null';
-    }
-    if (Array.isArray(what)) {
-      return 'array';
-    }
-    return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
-  }
-
-  if (to === 'number') {
-    if (Number.isFinite(what)) {
-      if (what % 1 === 0) {
-        return 'integer';
-      } else {
-        return 'number';
-      }
-    }
-    if (Number.isNaN(what)) {
-      return 'not-a-number';
-    }
-    return 'unknown-number';
-  }
-
-  return to; // undefined, boolean, string, function
-}
-
-/**
- *
- * @param {*} json1
- * @param {*} json2
- * @param {*} [options]
- *
- * @returns {boolean}
- */
-export function areEqual(json1, json2, options?) {
-  options = options || {};
-  const caseInsensitiveComparison = options.caseInsensitiveComparison || false;
-
-  // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
-
-  // Two JSON values are said to be equal if and only if:
-  // both are nulls; or
-  // both are booleans, and have the same value; or
-  // both are strings, and have the same value; or
-  // both are numbers, and have the same mathematical value; or
-  if (json1 === json2) {
-    return true;
-  }
-  if (
-    caseInsensitiveComparison === true &&
-    typeof json1 === 'string' &&
-    typeof json2 === 'string' &&
-    json1.toUpperCase() === json2.toUpperCase()
-  ) {
-    return true;
-  }
-
-  let i, len;
-
-  // both are arrays, and:
-  if (Array.isArray(json1) && Array.isArray(json2)) {
-    // have the same number of items; and
-    if (json1.length !== json2.length) {
-      return false;
-    }
-    // items at the same index are equal according to this definition; or
-    len = json1.length;
-    for (i = 0; i < len; i++) {
-      if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  // both are objects, and:
-  if (whatIs(json1) === 'object' && whatIs(json2) === 'object') {
-    // have the same set of property names; and
-    const keys1 = sortedKeys(json1);
-    const keys2 = sortedKeys(json2);
-    if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
-      return false;
-    }
-    // values for a same property name are equal according to this definition.
-    len = keys1.length;
-    for (i = 0; i < len; i++) {
-      if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  return false;
-}
-
-/**
- *
- * @param {*[]} arr
- * @param {number[]} [indexes]
- *
- * @returns {boolean}
- */
-export function isUniqueArray(arr, indexes?) {
-  let i;
-  let j;
-  const l = arr.length;
-  for (i = 0; i < l; i++) {
-    for (j = i + 1; j < l; j++) {
-      if (areEqual(arr[i], arr[j])) {
-        if (indexes) {
-          indexes.push(i, j);
-        }
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-/**
- *
- * @param {*} bigSet
- * @param {*} subSet
- *
- * @returns {*[]}
- */
-export function difference(bigSet, subSet) {
-  const arr = [];
-  let idx = bigSet.length;
-  while (idx--) {
-    if (subSet.indexOf(bigSet[idx]) === -1) {
-      arr.push(bigSet[idx]);
-    }
-  }
-  return arr;
-}
-
-// NOT a deep version of clone
-export function clone(src) {
-  if (typeof src === 'undefined') {
-    return void 0;
-  }
-  if (typeof src !== 'object' || src === null) {
-    return src;
-  }
-  let res, idx;
-  if (Array.isArray(src)) {
-    res = [];
-    idx = src.length;
-    while (idx--) {
-      res[idx] = src[idx];
-    }
-  } else {
-    res = {};
-    const keys = Object.keys(src);
-    idx = keys.length;
-    while (idx--) {
-      const key = keys[idx];
-      res[key] = src[key];
-    }
-  }
-  return res;
-}
-
-export function cloneDeep(src) {
-  let vidx = 0;
-  const visited = new Map();
-  const cloned = [];
-  function cloneDeepInner(src) {
-    if (typeof src !== 'object' || src === null) {
-      return src;
-    }
-
-    let res;
-    let idx;
-    const cidx = visited.get(src);
-
-    if (cidx !== undefined) {
-      return cloned[cidx];
-    }
-
-    visited.set(src, vidx++);
-    if (Array.isArray(src)) {
-      res = [];
-      cloned.push(res);
-      idx = src.length;
-      while (idx--) {
-        res[idx] = cloneDeepInner(src[idx]);
-      }
-    } else {
-      res = {};
-      cloned.push(res);
-      const keys = Object.keys(src);
-      idx = keys.length;
-      while (idx--) {
-        const key = keys[idx];
-        res[key] = cloneDeepInner(src[key]);
-      }
-    }
-    return res;
-  }
-  return cloneDeepInner(src);
-}
-
-/*
-  following function comes from punycode.js library
-  see: https://github.com/bestiejs/punycode.js
-*/
-/**
- * Creates an array containing the numeric code points of each Unicode
- * character in the string. While JavaScript uses UCS-2 internally,
- * this function will convert a pair of surrogate halves (each of which
- * UCS-2 exposes as separate characters) into a single code point,
- * matching UTF-16.
- * @see `punycode.ucs2.encode`
- * @see <https://mathiasbynens.be/notes/javascript-encoding>
- * @memberOf punycode.ucs2
- * @name decode
- * @param {String} string The Unicode input string (UCS-2).
- * @returns {Array} The new array of code points.
- */
-export function ucs2decode(string) {
-  const output = [];
-  let counter = 0;
-  const length = string.length;
-  let value;
-  let extra;
-  while (counter < length) {
-    value = string.charCodeAt(counter++);
-    if (value >= 0xd800 && value <= 0xdbff && counter < length) {
-      // high surrogate, and there is a next character
-      extra = string.charCodeAt(counter++);
-      if ((extra & 0xfc00) == 0xdc00) {
-        // low surrogate
-        output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-      } else {
-        // unmatched surrogate; only append this code unit, in case the next
-        // code unit is the high surrogate of a surrogate pair
-        output.push(value);
-        counter--;
-      }
-    } else {
-      output.push(value);
-    }
-  }
-  return output;
-}