z-schema 7.0.0 → 7.0.6

package/{src/FormatValidators.ts → dist/format-validators.js}

@@ -1,35 +1,35 @@
 import validator from 'validator';
-
-export const FormatValidators = {
-  date: function (date) {
+import { sortedKeys } from './utils/json.js';
+const { isEmail, isIP, isURL } = validator;
+const dateValidator = (date) => {
     if (typeof date !== 'string') {
-      return true;
+        return true;
     }
     // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
     const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
     if (matches === null) {
-      return false;
+        return false;
     }
     // var year = matches[1];
     // var month = matches[2];
     // var day = matches[3];
     if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
-      return false;
+        return false;
     }
     return true;
-  },
-  'date-time': function (dateTime) {
+};
+const dateTimeValidator = (dateTime) => {
     if (typeof dateTime !== 'string') {
-      return true;
+        return true;
     }
     // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
     const s = dateTime.toLowerCase().split('t');
-    if (!FormatValidators.date(s[0])) {
-      return false;
+    if (!dateValidator(s[0])) {
+        return false;
     }
     const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
     if (matches === null) {
-      return false;
+        return false;
     }
     // var hour = matches[1];
     // var minute = matches[2];
@@ -37,100 +37,132 @@ export const FormatValidators = {
     // var fraction = matches[4];
     // var timezone = matches[5];
     if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
-      return false;
+        return false;
     }
     return true;
-  },
-  email: function (email) {
+};
+const emailValidator = (email) => {
     if (typeof email !== 'string') {
-      return true;
+        return true;
     }
-    return validator.isEmail(email, { require_tld: true });
-  },
-  hostname: function (hostname) {
+    return isEmail(email, { require_tld: true });
+};
+const hostnameValidator = (hostname) => {
     if (typeof hostname !== 'string') {
-      return true;
+        return true;
     }
     /*
             http://json-schema.org/latest/json-schema-validation.html#anchor114
             A string instance is valid against this attribute if it is a valid
             representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
-
+  
             http://tools.ietf.org/html/rfc1034#section-3.5
-
+  
             <digit> ::= any one of the ten digits 0 through 9
             var digit = /[0-9]/;
-
+  
             <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
             var letter = /[a-zA-Z]/;
-
+  
             <let-dig> ::= <letter> | <digit>
             var letDig = /[0-9a-zA-Z]/;
-
+  
             <let-dig-hyp> ::= <let-dig> | "-"
             var letDigHyp = /[-0-9a-zA-Z]/;
-
+  
             <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
             var ldhStr = /[-0-9a-zA-Z]+/;
-
+  
             <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
             var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
-
+  
             <subdomain> ::= <label> | <subdomain> "." <label>
             var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
-
+  
             <domain> ::= <subdomain> | " "
             var domain = null;
         */
     const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
     if (valid) {
-      // the sum of all label octets and label lengths is limited to 255.
-      if (hostname.length > 255) {
-        return false;
-      }
-      // Each node has a label, which is zero to 63 octets in length
-      const labels = hostname.split('.');
-      for (let i = 0; i < labels.length; i++) {
-        if (labels[i].length > 63) {
-          return false;
+        // the sum of all label octets and label lengths is limited to 255.
+        if (hostname.length > 255) {
+            return false;
+        }
+        // Each node has a label, which is zero to 63 octets in length
+        const labels = hostname.split('.');
+        for (let i = 0; i < labels.length; i++) {
+            if (labels[i].length > 63) {
+                return false;
+            }
         }
-      }
     }
     return valid;
-  },
-  'host-name': function (hostname) {
-    return FormatValidators.hostname.call(this, hostname);
-  },
-  ipv4: function (ipv4) {
+};
+const ipv4Validator = (ipv4) => {
     if (typeof ipv4 !== 'string') {
-      return true;
+        return true;
     }
-    return validator.isIP(ipv4, 4);
-  },
-  ipv6: function (ipv6) {
+    return isIP(ipv4, 4);
+};
+const ipv6Validator = (ipv6) => {
     if (typeof ipv6 !== 'string') {
-      return true;
+        return true;
+    }
+    return isIP(ipv6, 6);
+};
+const regexValidator = (input) => {
+    if (typeof input !== 'string') {
+        return false;
     }
-    return validator.isIP(ipv6, 6);
-  },
-  regex: function (str) {
     try {
-      RegExp(str);
-      return true;
-    } catch (_e) {
-      return false;
+        RegExp(input);
+        return true;
     }
-  },
-  uri: function (...args: [string]) {
-    if (this.options.strictUris) {
-      return FormatValidators['strict-uri'].apply(this, args);
+    catch (_e) {
+        return false;
     }
-    const [uri] = args;
+};
+const strictUriValidator = (uri) => typeof uri !== 'string' || isURL(uri);
+const uriValidator = function (uri) {
     // https://github.com/zaggino/z-schema/issues/18
     // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
     return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
-  },
-  'strict-uri': function (uri) {
-    return typeof uri !== 'string' || validator.isURL(uri);
-  },
 };
+const inbuiltValidators = {
+    date: dateValidator,
+    'date-time': dateTimeValidator,
+    email: emailValidator,
+    hostname: hostnameValidator,
+    'host-name': hostnameValidator,
+    ipv4: ipv4Validator,
+    ipv6: ipv6Validator,
+    regex: regexValidator,
+    uri: uriValidator,
+    'strict-uri': strictUriValidator,
+};
+const customValidators = {};
+export function getFormatValidators(options) {
+    return {
+        ...inbuiltValidators,
+        ...(options?.strictUris ? { uri: strictUriValidator } : {}),
+        ...customValidators,
+    };
+}
+export function registerFormat(name, validatorFunction) {
+    customValidators[name] = validatorFunction;
+}
+export function unregisterFormat(name) {
+    delete customValidators[name];
+}
+export function getSupportedFormats() {
+    return sortedKeys({
+        ...inbuiltValidators,
+        ...customValidators,
+    });
+}
+export function isFormatSupported(name) {
+    return inbuiltValidators[name] != null || customValidators[name] != null;
+}
+export function getRegisteredFormats() {
+    return sortedKeys(customValidators);
+}

package/dist/index.js

@@ -1,2 +1,2 @@
-import { ZSchema } from './ZSchema.js';
+import { ZSchema } from './z-schema.js';
 export default ZSchema;

package/dist/json-schema.js

@@ -0,0 +1,40 @@
+import { isObject } from './utils/what-is.js';
+export const findId = (schema, id) => {
+    // process only arrays and objects
+    if (typeof schema !== 'object' || schema === null) {
+        return;
+    }
+    // no id means root so return itself
+    if (!id) {
+        return schema;
+    }
+    if (schema.id) {
+        if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+            return schema;
+        }
+    }
+    let idx, result;
+    if (Array.isArray(schema)) {
+        idx = schema.length;
+        while (idx--) {
+            result = findId(schema[idx], id);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    if (isObject(schema)) {
+        const keys = Object.keys(schema);
+        idx = keys.length;
+        while (idx--) {
+            const k = keys[idx];
+            if (k.indexOf('__$') === 0) {
+                continue;
+            }
+            result = findId(schema[k], id);
+            if (result) {
+                return result;
+            }
+        }
+    }
+};