z-schema 7.0.0 → 7.0.6

package/src/utils/array.ts

@@ -0,0 +1,29 @@
+import { areEqual } from './json.js';
+
+export const isUniqueArray = <T>(arr: T[], indexes?: number[]): boolean => {
+  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;
+};
+
+export const difference = (bigSet: any[], subSet: any[]) => {
+  const arr = [];
+  let idx = bigSet.length;
+  while (idx--) {
+    if (subSet.indexOf(bigSet[idx]) === -1) {
+      arr.push(bigSet[idx]);
+    }
+  }
+  return arr;
+};

package/src/utils/clone.ts

@@ -0,0 +1,63 @@
+export const shallowClone = <T>(src: T): T => {
+  if (src == null || typeof src !== 'object') {
+    return src;
+  }
+  let res: any;
+  let idx;
+  if (Array.isArray(src)) {
+    res = [];
+    idx = src.length;
+    while (idx--) {
+      res[idx] = src[idx];
+    }
+  } else {
+    res = {};
+    const keys = Object.keys(src) as Array<keyof T>;
+    idx = keys.length;
+    while (idx--) {
+      const key = keys[idx];
+      res[key] = src[key];
+    }
+  }
+  return res;
+};
+
+export const deepClone = <T>(src: T): T => {
+  let vidx = 0;
+  const visited = new Map();
+  const cloned: any[] = [];
+  const cloneDeepInner = <T>(src: T): T => {
+    if (typeof src !== 'object' || src === null) {
+      return src;
+    }
+
+    let res: any;
+    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) as Array<keyof T>;
+      idx = keys.length;
+      while (idx--) {
+        const key = keys[idx];
+        res[key] = cloneDeepInner(src[key]);
+      }
+    }
+    return res;
+  };
+  return cloneDeepInner(src);
+};

package/src/utils/json.ts

@@ -0,0 +1,74 @@
+import { isObject } from './what-is.js';
+
+interface AreEqualOptions {
+  caseInsensitiveComparison?: boolean;
+}
+
+export const areEqual = (json1: unknown, json2: unknown, options?: AreEqualOptions): boolean => {
+  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 (isObject(json1) && isObject(json2)) {
+    // have the same set of property names; and
+    const keys1 = sortedKeys(json1 as Record<string, unknown>);
+    const keys2 = sortedKeys(json2 as Record<string, unknown>);
+    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;
+};
+
+export const decodeJSONPointer = (str: string) => {
+  // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
+  return decodeURIComponent(str).replace(/~[0-1]/g, (x) => (x === '~1' ? '/' : '~'));
+};
+
+export const sortedKeys = (obj: Record<string, unknown>): string[] => Object.keys(obj).sort();

package/src/utils/symbols.ts

@@ -0,0 +1,3 @@
+export const jsonSymbol = Symbol.for('z-schema/json');
+
+export const schemaSymbol = Symbol.for('z-schema/schema');

package/src/utils/unicode.ts

@@ -0,0 +1,43 @@
+/*
+  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: string): number[] {
+  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;
+}

package/src/utils/uri.ts

@@ -0,0 +1,18 @@
+export const getQueryPath = (uri: string) => {
+  const io = uri.indexOf('#');
+  const res = io === -1 ? undefined : uri.slice(io + 1);
+  // WARN: do not slice slash, #/ means take root and go down from it
+  // if (res && res[0] === "/") { res = res.slice(1); }
+  return res;
+};
+
+export const getRemotePath = (uri: string) => {
+  const io = uri.indexOf('#');
+  return io === -1 ? uri : uri.slice(0, io);
+};
+
+export const isAbsoluteUri = (uri: string): boolean => /^https?:\/\//.test(uri);
+
+export const isRelativeUri = (uri: string): boolean =>
+  // relative URIs that end with a hash sign, issue #56
+  /.+#/.test(uri);

package/src/utils/what-is.ts

@@ -0,0 +1,46 @@
+export type WHAT_IS =
+  | 'undefined'
+  | 'null'
+  | 'object'
+  | 'array'
+  | 'integer'
+  | 'number'
+  | 'string'
+  | 'not-a-number'
+  | 'unknown-number'
+  | 'bigint'
+  | 'boolean'
+  | 'symbol'
+  | 'function';
+
+export const whatIs = (what: unknown): WHAT_IS => {
+  if (typeof what === 'object') {
+    if (what === null) {
+      return 'null';
+    }
+    if (Array.isArray(what)) {
+      return 'array';
+    }
+    return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
+  }
+
+  if (typeof what === '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 typeof what; // undefined, boolean, string, function
+};
+
+export function isObject(value: unknown): value is Record<any, any> {
+  return whatIs(value) === 'object';
+}