@sanity/validation 3.0.0-v3-pkg-utils.54 → 3.0.0-v3-pkg-utils.59

package/lib/index.js

@@ -1,14 +1,27 @@
+const _excluded = ["value", "type", "path", "parent"];
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 import { cloneDeep, get, memoize, uniqBy } from 'lodash';
 import { isKeyedObject, isReference, isBlock, isBlockSchemaType, isSpanSchemaType, isTypedObject } from '@sanity/types';
 import formatDate from 'date-fns/format';
-
 const ValidationError = class ValidationError2 {
-  constructor(message, options = {}) {
+  constructor(message) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     this.message = message;
     this.paths = options.paths || [];
     this.children = options.children;
     this.operation = options.operation;
   }
+
   cloneWithMessage(msg) {
     return new ValidationError2(msg, {
       paths: this.paths,
@@ -16,94 +29,98 @@ const ValidationError = class ValidationError2 {
       operation: this.operation
     });
   }
+
 };
 
-var escapeRegex = (string) => {
+var escapeRegex = string => {
   return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, "\\$&");
 };
 
-function pathToString(path = []) {
+function pathToString() {
+  let path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return path.reduce((target, segment, i) => {
     const segmentType = typeof segment;
+
     if (segmentType === "number") {
-      return `${target}[${segment}]`;
+      return "".concat(target, "[").concat(segment, "]");
     }
+
     if (segmentType === "string") {
       const separator = i === 0 ? "" : ".";
-      return `${target}${separator}${segment}`;
+      return "".concat(target).concat(separator).concat(segment);
     }
+
     if (isKeyedObject(segment)) {
-      return `${target}[_key=="${segment._key}"]`;
+      return "".concat(target, "[_key==\"").concat(segment._key, "\"]");
     }
-    throw new Error(`Unsupported path segment "${segment}"`);
+
+    throw new Error("Unsupported path segment \"".concat(segment, "\""));
   }, "");
 }
 
 function isNonNullable$1(t) {
   return t !== null || t !== void 0;
 }
+
 function convertToValidationMarker(validatorResult, level, context) {
   var _a;
+
   if (!context) {
     throw new Error("missing context");
   }
-  if (validatorResult === true)
-    return [];
+
+  if (validatorResult === true) return [];
+
   if (Array.isArray(validatorResult)) {
-    return validatorResult.flatMap((child) => convertToValidationMarker(child, level, context)).filter(isNonNullable$1);
+    return validatorResult.flatMap(child => convertToValidationMarker(child, level, context)).filter(isNonNullable$1);
   }
+
   if (typeof validatorResult === "string") {
     return convertToValidationMarker(new ValidationError(validatorResult), level, context);
   }
+
   if (!(validatorResult instanceof ValidationError)) {
     if (typeof (validatorResult == null ? void 0 : validatorResult.message) !== "string") {
-      throw new Error(
-        `${pathToString(
-          context.path
-        )}: Validator must return 'true' if valid or an error message as a string on errors`
-      );
-    }
-    return convertToValidationMarker(
-      new ValidationError(validatorResult.message, validatorResult),
-      level,
-      context
-    );
+      throw new Error("".concat(pathToString(context.path), ": Validator must return 'true' if valid or an error message as a string on errors"));
+    }
+
+    return convertToValidationMarker(new ValidationError(validatorResult.message, validatorResult), level, context);
   }
+
   const results = [];
+
   if (!((_a = validatorResult.paths) == null ? void 0 : _a.length)) {
-    return [
-      {
-        level: level || "error",
-        item: validatorResult,
-        path: context.path || []
-      }
-    ];
-  }
-  return results.concat(
-    validatorResult.paths.map((path) => ({
-      path: (context.path || []).concat(path),
+    return [{
       level: level || "error",
-      item: validatorResult
-    }))
-  );
+      item: validatorResult,
+      path: context.path || []
+    }];
+  }
+
+  return results.concat(validatorResult.paths.map(path => ({
+    path: (context.path || []).concat(path),
+    level: level || "error",
+    item: validatorResult
+  })));
 }
 
 const _toString = {}.toString;
 const builtIns = [Object, Function, Array, String, Boolean, Number, Date, RegExp, Error];
+
 function isBuiltIn(_constructor) {
   for (let i = 0; i < builtIns.length; i++) {
-    if (builtIns[i] === _constructor)
-      return true;
+    if (builtIns[i] === _constructor) return true;
   }
+
   return false;
 }
+
 function typeString(obj) {
   const stringType = _toString.call(obj).slice(8, -1);
-  if (obj === null || obj === void 0)
-    return stringType.toLowerCase();
+
+  if (obj === null || obj === void 0) return stringType.toLowerCase();
   const constructorType = obj.constructor;
-  if (constructorType && !isBuiltIn(constructorType))
-    return constructorType.name;
+  if (constructorType && !isBuiltIn(constructorType)) return constructorType.name;
   return stringType;
 }
 
@@ -111,93 +128,116 @@ function deepEquals(a, b) {
   if (a === b) {
     return true;
   }
+
   if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length != b.length)
-      return false;
+    if (a.length != b.length) return false;
+
     for (let i = 0; i < a.length; i++) {
       if (!deepEquals(a[i], b[i])) {
         return false;
       }
     }
+
     return true;
   }
+
   if (Array.isArray(a) != Array.isArray(b)) {
     return false;
   }
+
   if (a && b && typeof a === "object" && typeof b === "object") {
     const keys = Object.keys(a);
+
     if (keys.length !== Object.keys(b).length) {
       return false;
     }
+
     if (a instanceof Date && b instanceof Date) {
       return a.getTime() === b.getTime();
     }
+
     if (a instanceof Date != b instanceof Date) {
       return false;
     }
+
     if (a instanceof RegExp && b instanceof RegExp) {
       return a.toString() == b.toString();
     }
+
     if (a instanceof RegExp != b instanceof RegExp) {
       return false;
     }
+
     for (let i = 0; i < keys.length; i++) {
       if (keys[i] === "_key") {
         continue;
       }
+
       if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
         return false;
       }
     }
+
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
+
       if (key === "_key") {
         continue;
       }
+
       if (!deepEquals(a[key], b[key])) {
         return false;
       }
     }
+
     return true;
   }
+
   return false;
 }
 
 const SLOW_VALIDATOR_TIMEOUT = 5e3;
-const formatValidationErrors = (options) => {
+
+const formatValidationErrors = options => {
   var _a;
+
   let message;
+
   if (options.message) {
     message = options.message;
   } else if (options.results.length === 1) {
     message = (_a = options.results[0]) == null ? void 0 : _a.item.message;
   } else {
-    message = `[${options.results.map((err) => err.item.message).join(` - ${options.operation} - `)}]`;
+    message = "[".concat(options.results.map(err => err.item.message).join(" - ".concat(options.operation, " - ")), "]");
   }
+
   return new ValidationError(message, {
     children: options.results.length > 1 ? options.results : void 0,
     operation: options.operation
   });
 };
+
 const genericValidators = {
   type: (expected, value, message) => {
     const actualType = typeString(value);
+
     if (actualType !== expected && actualType !== "undefined") {
-      return message || `Expected type "${expected}", got "${actualType}"`;
+      return message || "Expected type \"".concat(expected, "\", got \"").concat(actualType, "\"");
     }
+
     return true;
   },
   presence: (expected, value, message) => {
     if (value === void 0 && expected === "required") {
       return message || "Value is required";
     }
+
     return true;
   },
   all: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)));
+    const resolved = await Promise.all(children.map(child => child.validate(value, context)));
     const results = resolved.flat();
-    if (!results.length)
-      return true;
+    if (!results.length) return true;
     return formatValidationErrors({
       message,
       results,
@@ -205,10 +245,9 @@ const genericValidators = {
     });
   },
   either: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)));
+    const resolved = await Promise.all(children.map(child => child.validate(value, context)));
     const results = resolved.flat();
-    if (results.length < children.length)
-      return true;
+    if (results.length < children.length) return true;
     return formatValidationErrors({
       message,
       results,
@@ -217,368 +256,461 @@ const genericValidators = {
   },
   valid: (allowedValues, actual, message) => {
     const valueType = typeof actual;
+
     if (valueType === "undefined") {
       return true;
     }
-    const value = (valueType === "number" || valueType === "string") && `${actual}`;
-    const strValue = value && value.length > 30 ? `${value.slice(0, 30)}\u2026` : value;
-    const defaultMessage = value ? `Value "${strValue}" did not match any allowed values` : "Value did not match any allowed values";
-    return allowedValues.some((expected) => deepEquals(expected, actual)) ? true : message || defaultMessage;
+
+    const value = (valueType === "number" || valueType === "string") && "".concat(actual);
+    const strValue = value && value.length > 30 ? "".concat(value.slice(0, 30), "\u2026") : value;
+    const defaultMessage = value ? "Value \"".concat(strValue, "\" did not match any allowed values") : "Value did not match any allowed values";
+    return allowedValues.some(expected => deepEquals(expected, actual)) ? true : message || defaultMessage;
   },
   custom: async (fn, value, message, context) => {
     const slowTimer = setTimeout(() => {
-      console.warn(
-        `Custom validator at ${pathToString(
-          context.path
-        )} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`
-      );
+      console.warn("Custom validator at ".concat(pathToString(context.path), " has taken more than ").concat(SLOW_VALIDATOR_TIMEOUT, "ms to respond"));
     }, SLOW_VALIDATOR_TIMEOUT);
     let result;
+
     try {
       result = await fn(value, context);
     } finally {
       clearTimeout(slowTimer);
     }
-    if (typeof result === "string")
-      return message || result;
+
+    if (typeof result === "string") return message || result;
     return result;
   }
 };
 
-const booleanValidators = {
-  ...genericValidators,
+const booleanValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   presence: (flag, value, message) => {
     if (flag === "required" && typeof value !== "boolean") {
       return message || "Required";
     }
+
     return true;
   }
-};
+});
 
 const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
-const numberValidators = {
-  ...genericValidators,
+
+const numberValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   integer: (_unused, value, message) => {
     if (!Number.isInteger(value)) {
       return message || "Must be an integer";
     }
+
     return true;
   },
   precision: (limit, value, message) => {
-    if (value === void 0)
-      return true;
+    if (value === void 0) return true;
     const places = value.toString().match(precisionRx);
-    const decimals = Math.max(
-      (places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0),
-      0
-    );
+    const decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+
     if (decimals > limit) {
-      return message || `Max precision is ${limit}`;
+      return message || "Max precision is ".concat(limit);
     }
+
     return true;
   },
   min: (minNum, value, message) => {
     if (value >= minNum) {
       return true;
     }
-    return message || `Must be greater than or equal ${minNum}`;
+
+    return message || "Must be greater than or equal ".concat(minNum);
   },
   max: (maxNum, value, message) => {
     if (value <= maxNum) {
       return true;
     }
-    return message || `Must be less than or equal ${maxNum}`;
+
+    return message || "Must be less than or equal ".concat(maxNum);
   },
   greaterThan: (num, value, message) => {
     if (value > num) {
       return true;
     }
-    return message || `Must be greater than ${num}`;
+
+    return message || "Must be greater than ".concat(num);
   },
   lessThan: (maxNum, value, message) => {
     if (value < maxNum) {
       return true;
     }
-    return message || `Must be less than ${maxNum}`;
+
+    return message || "Must be less than ".concat(maxNum);
   }
-};
+});
 
 const DUMMY_ORIGIN = "http://sanity";
 const emailRegex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-const isRelativeUrl = (url) => /^\.*\//.test(url);
-const stringValidators = {
-  ...genericValidators,
+
+const isRelativeUrl = url => /^\.*\//.test(url);
+
+const stringValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
     }
-    return message || `Must be at least ${minLength} characters long`;
+
+    return message || "Must be at least ".concat(minLength, " characters long");
   },
   max: (maxLength, value, message) => {
     if (!value || value.length <= maxLength) {
       return true;
     }
-    return message || `Must be at most ${maxLength} characters long`;
+
+    return message || "Must be at most ".concat(maxLength, " characters long");
   },
   length: (wantedLength, value, message) => {
     const strValue = value || "";
+
     if (strValue.length === wantedLength) {
       return true;
     }
-    return message || `Must be exactly ${wantedLength} characters long`;
+
+    return message || "Must be exactly ".concat(wantedLength, " characters long");
   },
   uri: (constraints, value, message) => {
     const strValue = value || "";
-    const { options } = constraints;
-    const { allowCredentials, relativeOnly } = options;
+    const {
+      options
+    } = constraints;
+    const {
+      allowCredentials,
+      relativeOnly
+    } = options;
     const allowRelative = options.allowRelative || relativeOnly;
     let url;
+
     try {
       url = allowRelative ? new URL(strValue, DUMMY_ORIGIN) : new URL(strValue);
     } catch (err) {
       return message || "Not a valid URL";
     }
+
     if (relativeOnly && url.origin !== DUMMY_ORIGIN) {
       return message || "Only relative URLs are allowed";
     }
+
     if (!allowRelative && url.origin === DUMMY_ORIGIN && isRelativeUrl(strValue)) {
       return message || "Relative URLs are not allowed";
     }
+
     if (!allowCredentials && (url.username || url.password)) {
-      return message || `Username/password not allowed`;
+      return message || "Username/password not allowed";
     }
+
     const urlScheme = url.protocol.replace(/:$/, "");
-    const matchesAllowedScheme = options.scheme.some((scheme) => scheme.test(urlScheme));
+    const matchesAllowedScheme = options.scheme.some(scheme => scheme.test(urlScheme));
+
     if (!matchesAllowedScheme) {
       return message || "Does not match allowed protocols/schemes";
     }
+
     return true;
   },
   stringCasing: (casing, value, message) => {
     const strValue = value || "";
+
     if (casing === "uppercase" && strValue !== strValue.toLocaleUpperCase()) {
-      return message || `Must be all uppercase letters`;
+      return message || "Must be all uppercase letters";
     }
+
     if (casing === "lowercase" && strValue !== strValue.toLocaleLowerCase()) {
-      return message || `Must be all lowercase letters`;
+      return message || "Must be all lowercase letters";
     }
+
     return true;
   },
   presence: (flag, value, message) => {
     if (flag === "required" && !value) {
       return message || "Required";
     }
+
     return true;
   },
   regex: (options, value, message) => {
-    const { pattern, name, invert } = options;
-    const regName = name || `"${pattern.toString()}"`;
+    const {
+      pattern,
+      name,
+      invert
+    } = options;
+    const regName = name || "\"".concat(pattern.toString(), "\"");
     const strValue = value || "";
     const matches = pattern.test(strValue);
+
     if (!invert && !matches || invert && matches) {
-      const defaultMessage = invert ? `Should not match ${regName}-pattern` : `Does not match ${regName}-pattern`;
+      const defaultMessage = invert ? "Should not match ".concat(regName, "-pattern") : "Does not match ".concat(regName, "-pattern");
       return message || defaultMessage;
     }
+
     return true;
   },
   email: (_unused, value, message) => {
-    const strValue = `${value || ""}`.trim();
+    const strValue = "".concat(value || "").trim();
+
     if (!strValue || emailRegex.test(strValue)) {
       return true;
     }
+
     return message || "Must be a valid email address";
   }
-};
+});
 
-const arrayValidators = {
-  ...genericValidators,
+const arrayValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
     }
-    return message || `Must have at least ${minLength} items`;
+
+    return message || "Must have at least ".concat(minLength, " items");
   },
   max: (maxLength, value, message) => {
     if (!value || value.length <= maxLength) {
       return true;
     }
-    return message || `Must have at most ${maxLength} items`;
+
+    return message || "Must have at most ".concat(maxLength, " items");
   },
   length: (wantedLength, value, message) => {
     if (!value || value.length === wantedLength) {
       return true;
     }
-    return message || `Must have exactly ${wantedLength} items`;
+
+    return message || "Must have exactly ".concat(wantedLength, " items");
   },
   presence: (flag, value, message) => {
     if (flag === "required" && !value) {
       return message || "Required";
     }
+
     return true;
   },
   valid: (allowedValues, values, message) => {
     const valueType = typeof values;
+
     if (valueType === "undefined") {
       return true;
     }
+
     const paths = [];
+
     for (let i = 0; i < values.length; i++) {
       const value = values[i];
-      if (allowedValues.some((expected) => deepEquals(expected, value))) {
+
+      if (allowedValues.some(expected => deepEquals(expected, value))) {
         continue;
       }
-      const pathSegment = value && value._key ? { _key: value._key } : i;
+
+      const pathSegment = value && value._key ? {
+        _key: value._key
+      } : i;
       paths.push([pathSegment]);
     }
-    return paths.length === 0 ? true : new ValidationError(message || "Value did not match any allowed values", { paths });
+
+    return paths.length === 0 ? true : new ValidationError(message || "Value did not match any allowed values", {
+      paths
+    });
   },
   unique: (_unused, value, message) => {
     const dupeIndices = [];
+
     if (!value) {
       return true;
     }
+
     for (let x = 0; x < value.length; x++) {
       for (let y = x + 1; y < value.length; y++) {
         const itemA = value[x];
         const itemB = value[y];
+
         if (!deepEquals(itemA, itemB)) {
           continue;
         }
+
         if (dupeIndices.indexOf(x) === -1) {
           dupeIndices.push(x);
         }
+
         if (dupeIndices.indexOf(y) === -1) {
           dupeIndices.push(y);
         }
       }
     }
-    const paths = dupeIndices.map((idx) => {
+
+    const paths = dupeIndices.map(idx => {
       const item = value[idx];
-      const pathSegment = item && item._key ? { _key: item._key } : idx;
+      const pathSegment = item && item._key ? {
+        _key: item._key
+      } : idx;
       return [pathSegment];
     });
-    return dupeIndices.length > 0 ? new ValidationError(message || `Can't be a duplicate`, { paths }) : true;
+    return dupeIndices.length > 0 ? new ValidationError(message || "Can't be a duplicate", {
+      paths
+    }) : true;
   }
-};
+});
 
 const metaKeys = ["_key", "_type", "_weak"];
-const objectValidators = {
-  ...genericValidators,
+
+const objectValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   presence: (expected, value, message) => {
     if (expected !== "required") {
       return true;
     }
-    const keys = value && Object.keys(value).filter((key) => !metaKeys.includes(key));
+
+    const keys = value && Object.keys(value).filter(key => !metaKeys.includes(key));
+
     if (value === void 0 || keys && keys.length === 0) {
       return message || "Required";
     }
+
     return true;
   },
   reference: async (_unused, value, message, context) => {
     if (!value) {
       return true;
     }
+
     if (!isReference(value)) {
       return message || true;
     }
-    const { type, getDocumentExists } = context;
+
+    const {
+      type,
+      getDocumentExists
+    } = context;
+
     if (!type) {
-      throw new Error(`\`type\` was not provided in validation context`);
+      throw new Error("`type` was not provided in validation context");
     }
+
     if ("weak" in type && type.weak) {
       return true;
     }
+
     if (!getDocumentExists) {
-      throw new Error(`\`getDocumentExists\` was not provided in validation context`);
+      throw new Error("`getDocumentExists` was not provided in validation context");
     }
-    const exists = await getDocumentExists({ id: value._ref });
+
+    const exists = await getDocumentExists({
+      id: value._ref
+    });
+
     if (!exists) {
       return "This reference must be published";
     }
+
     return true;
   },
   assetRequired: (flag, value, message) => {
     if (!value || !value.asset || !value.asset._ref) {
       const assetType = flag.assetType || "Asset";
-      return message || `${assetType} required`;
+      return message || "".concat(assetType, " required");
     }
+
     return true;
   }
-};
+});
 
 function isRecord$1(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
+
 const isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/;
-const getFormattedDate = (type = "", value, options) => {
+
+const getFormattedDate = function () {
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  let value = arguments.length > 1 ? arguments[1] : undefined;
+  let options = arguments.length > 2 ? arguments[2] : undefined;
   let format = "yyyy-MM-dd";
+
   if (options && options.dateFormat) {
     format = options.dateFormat;
   }
+
   if (type === "date") {
     return formatDate(new Date(value), format);
   }
+
   if (options && options.timeFormat) {
-    format += ` ${options.timeFormat}`;
+    format += " ".concat(options.timeFormat);
   } else {
     format += " HH:mm";
   }
+
   return formatDate(new Date(value), format);
 };
-function parseDate(date, throwOnError = false) {
-  if (!date)
-    return null;
-  if (date === "now")
-    return new Date();
+
+function parseDate(date) {
+  let throwOnError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (!date) return null;
+  if (date === "now") return new Date();
   const parsed = new Date(date);
   const isInvalid = isNaN(parsed.getTime());
+
   if (isInvalid && throwOnError) {
-    throw new Error(`Unable to parse "${date}" to a date`);
+    throw new Error("Unable to parse \"".concat(date, "\" to a date"));
   }
+
   return isInvalid ? null : parsed;
 }
-const dateValidators = {
-  ...genericValidators,
+
+const dateValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   type: (_unused, value, message) => {
-    const strVal = `${value}`;
+    const strVal = "".concat(value);
+
     if (!strVal || isoDate.test(value)) {
       return true;
     }
+
     return message || "Must be a valid ISO-8601 formatted date string";
   },
   min: (minDate, value, message, context) => {
     const dateVal = parseDate(value);
+
     if (!dateVal) {
       return true;
     }
+
     if (!value || dateVal >= parseDate(minDate, true)) {
       return true;
     }
+
     if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`);
+      throw new Error("`type` was not provided in validation context.");
     }
+
     const dateTimeOptions = isRecord$1(context.type.options) ? context.type.options : {};
     const date = getFormattedDate(context.type.name, minDate, dateTimeOptions);
-    return message || `Must be at or after ${date}`;
+    return message || "Must be at or after ".concat(date);
   },
   max: (maxDate, value, message, context) => {
     const dateVal = parseDate(value);
+
     if (!dateVal) {
       return true;
     }
+
     if (!value || dateVal <= parseDate(maxDate, true)) {
       return true;
     }
+
     if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`);
+      throw new Error("`type` was not provided in validation context.");
     }
+
     const dateTimeOptions = isRecord$1(context.type.options) ? context.type.options : {};
     const date = getFormattedDate(context.type.name, maxDate, dateTimeOptions);
-    return message || `Must be at or before ${date}`;
+    return message || "Must be at or before ".concat(date);
   }
-};
+});
 
 var _a;
+
 const typeValidators = {
   Boolean: booleanValidators,
   Number: numberValidators,
@@ -587,24 +719,19 @@ const typeValidators = {
   Object: objectValidators,
   Date: dateValidators
 };
-const getBaseType = (type) => {
+
+const getBaseType = type => {
   return type && type.type ? getBaseType(type.type) : type;
 };
-const isFieldRef = (constraint) => {
-  if (typeof constraint !== "object" || !constraint)
-    return false;
+
+const isFieldRef = constraint => {
+  if (typeof constraint !== "object" || !constraint) return false;
   return constraint.type === Rule.FIELD_REF;
 };
+
 const EMPTY_ARRAY = [];
 const FIELD_REF = Symbol("FIELD_REF");
-const ruleConstraintTypes$1 = [
-  "Array",
-  "Boolean",
-  "Date",
-  "Number",
-  "Object",
-  "String"
-];
+const ruleConstraintTypes$1 = ["Array", "Boolean", "Date", "Number", "Object", "String"];
 const Rule = (_a = class {
   constructor(typeDef) {
     this._type = void 0;
@@ -618,43 +745,48 @@ const Rule = (_a = class {
     this._typeDef = typeDef;
     this.reset();
   }
+
   _mergeRequired(next) {
-    if (this._required === "required" || next._required === "required")
-      return "required";
-    if (this._required === "optional" || next._required === "optional")
-      return "optional";
+    if (this._required === "required" || next._required === "required") return "required";
+    if (this._required === "optional" || next._required === "optional") return "optional";
     return void 0;
   }
+
   error(message) {
     const rule = this.clone();
     rule._level = "error";
     rule._message = message || void 0;
     return rule;
   }
+
   warning(message) {
     const rule = this.clone();
     rule._level = "warning";
     rule._message = message || void 0;
     return rule;
   }
+
   info(message) {
     const rule = this.clone();
     rule._level = "info";
     rule._message = message || void 0;
     return rule;
   }
+
   reset() {
     this._type = this._type || void 0;
-    this._rules = (this._rules || []).filter((rule) => rule.flag === "type");
+    this._rules = (this._rules || []).filter(rule => rule.flag === "type");
     this._message = void 0;
     this._required = void 0;
     this._level = "error";
     this._fieldRules = void 0;
     return this;
   }
+
   isRequired() {
     return this._required === "required";
   }
+
   clone() {
     const rule = new _a();
     rule._type = this._type;
@@ -666,26 +798,30 @@ const Rule = (_a = class {
     rule._typeDef = this._typeDef;
     return rule;
   }
+
   cloneWithRules(rules) {
     const rule = this.clone();
-    const newRules = /* @__PURE__ */ new Set();
-    rules.forEach((curr) => {
+    const newRules = /* @__PURE__ */new Set();
+    rules.forEach(curr => {
       if (curr.flag === "type") {
         rule._type = curr.constraint;
       }
+
       newRules.add(curr.flag);
     });
-    rule._rules = rule._rules.filter((curr) => {
+    rule._rules = rule._rules.filter(curr => {
       const disallowDuplicate = ["type", "uri", "email"].includes(curr.flag);
       const isDuplicate = newRules.has(curr.flag);
       return !(disallowDuplicate && isDuplicate);
     }).concat(rules);
     return rule;
   }
+
   merge(rule) {
     if (this._type && rule._type && this._type !== rule._type) {
       throw new Error("merge() failed: conflicting types");
     }
+
     const newRule = this.cloneWithRules(rule._rules);
     newRule._type = this._type || rule._type;
     newRule._message = this._message || rule._message;
@@ -693,76 +829,155 @@ const Rule = (_a = class {
     newRule._level = this._level === "error" ? rule._level : this._level;
     return newRule;
   }
+
   type(targetType) {
-    const type = `${targetType.slice(0, 1).toUpperCase()}${targetType.slice(1)}`;
+    const type = "".concat(targetType.slice(0, 1).toUpperCase()).concat(targetType.slice(1));
+
     if (!ruleConstraintTypes$1.includes(type)) {
-      throw new Error(`Unknown type "${targetType}"`);
+      throw new Error("Unknown type \"".concat(targetType, "\""));
     }
-    const rule = this.cloneWithRules([{ flag: "type", constraint: type }]);
+
+    const rule = this.cloneWithRules([{
+      flag: "type",
+      constraint: type
+    }]);
     rule._type = type;
     return rule;
   }
+
   all(children) {
-    return this.cloneWithRules([{ flag: "all", constraint: children }]);
+    return this.cloneWithRules([{
+      flag: "all",
+      constraint: children
+    }]);
   }
+
   either(children) {
-    return this.cloneWithRules([{ flag: "either", constraint: children }]);
+    return this.cloneWithRules([{
+      flag: "either",
+      constraint: children
+    }]);
   }
+
   optional() {
-    const rule = this.cloneWithRules([{ flag: "presence", constraint: "optional" }]);
+    const rule = this.cloneWithRules([{
+      flag: "presence",
+      constraint: "optional"
+    }]);
     rule._required = "optional";
     return rule;
   }
+
   required() {
-    const rule = this.cloneWithRules([{ flag: "presence", constraint: "required" }]);
+    const rule = this.cloneWithRules([{
+      flag: "presence",
+      constraint: "required"
+    }]);
     rule._required = "required";
     return rule;
   }
+
   custom(fn) {
-    return this.cloneWithRules([{ flag: "custom", constraint: fn }]);
+    return this.cloneWithRules([{
+      flag: "custom",
+      constraint: fn
+    }]);
   }
+
   block(fn) {
-    return this.cloneWithRules([{ flag: "custom", constraint: fn }]);
+    return this.cloneWithRules([{
+      flag: "custom",
+      constraint: fn
+    }]);
   }
+
   min(len) {
-    return this.cloneWithRules([{ flag: "min", constraint: len }]);
+    return this.cloneWithRules([{
+      flag: "min",
+      constraint: len
+    }]);
   }
+
   max(len) {
-    return this.cloneWithRules([{ flag: "max", constraint: len }]);
+    return this.cloneWithRules([{
+      flag: "max",
+      constraint: len
+    }]);
   }
+
   length(len) {
-    return this.cloneWithRules([{ flag: "length", constraint: len }]);
+    return this.cloneWithRules([{
+      flag: "length",
+      constraint: len
+    }]);
   }
+
   valid(value) {
     const values = Array.isArray(value) ? value : [value];
-    return this.cloneWithRules([{ flag: "valid", constraint: values }]);
+    return this.cloneWithRules([{
+      flag: "valid",
+      constraint: values
+    }]);
   }
+
   integer() {
-    return this.cloneWithRules([{ flag: "integer" }]);
+    return this.cloneWithRules([{
+      flag: "integer"
+    }]);
   }
+
   precision(limit) {
-    return this.cloneWithRules([{ flag: "precision", constraint: limit }]);
+    return this.cloneWithRules([{
+      flag: "precision",
+      constraint: limit
+    }]);
   }
+
   positive() {
-    return this.cloneWithRules([{ flag: "min", constraint: 0 }]);
+    return this.cloneWithRules([{
+      flag: "min",
+      constraint: 0
+    }]);
   }
+
   negative() {
-    return this.cloneWithRules([{ flag: "lessThan", constraint: 0 }]);
+    return this.cloneWithRules([{
+      flag: "lessThan",
+      constraint: 0
+    }]);
   }
+
   greaterThan(num) {
-    return this.cloneWithRules([{ flag: "greaterThan", constraint: num }]);
+    return this.cloneWithRules([{
+      flag: "greaterThan",
+      constraint: num
+    }]);
   }
+
   lessThan(num) {
-    return this.cloneWithRules([{ flag: "lessThan", constraint: num }]);
+    return this.cloneWithRules([{
+      flag: "lessThan",
+      constraint: num
+    }]);
   }
+
   uppercase() {
-    return this.cloneWithRules([{ flag: "stringCasing", constraint: "uppercase" }]);
+    return this.cloneWithRules([{
+      flag: "stringCasing",
+      constraint: "uppercase"
+    }]);
   }
+
   lowercase() {
-    return this.cloneWithRules([{ flag: "stringCasing", constraint: "lowercase" }]);
+    return this.cloneWithRules([{
+      flag: "stringCasing",
+      constraint: "lowercase"
+    }]);
   }
+
   regex(pattern, a, b) {
     var _a2, _b;
+
     const name = typeof a === "string" ? a : (_a2 = a == null ? void 0 : a.name) != null ? _a2 : b == null ? void 0 : b.name;
     const invert = typeof a === "string" ? false : (_b = a == null ? void 0 : a.invert) != null ? _b : b == null ? void 0 : b.invert;
     const constraint = {
@@ -770,175 +985,226 @@ const Rule = (_a = class {
       name,
       invert: invert || false
     };
-    return this.cloneWithRules([{ flag: "regex", constraint }]);
+    return this.cloneWithRules([{
+      flag: "regex",
+      constraint
+    }]);
   }
+
   email() {
-    return this.cloneWithRules([{ flag: "email" }]);
+    return this.cloneWithRules([{
+      flag: "email"
+    }]);
   }
+
   uri(opts) {
     const optsScheme = (opts == null ? void 0 : opts.scheme) || ["http", "https"];
     const schemes = Array.isArray(optsScheme) ? optsScheme : [optsScheme];
+
     if (!schemes.length) {
       throw new Error("scheme must have at least 1 scheme specified");
     }
+
     const constraint = {
       options: {
-        scheme: schemes.map((scheme) => {
+        scheme: schemes.map(scheme => {
           if (!(scheme instanceof RegExp) && typeof scheme !== "string") {
             throw new Error("scheme must be a RegExp or a String");
           }
-          return typeof scheme === "string" ? new RegExp(`^${escapeRegex(scheme)}$`) : scheme;
+
+          return typeof scheme === "string" ? new RegExp("^".concat(escapeRegex(scheme), "$")) : scheme;
         }),
         allowRelative: (opts == null ? void 0 : opts.allowRelative) || false,
         relativeOnly: (opts == null ? void 0 : opts.relativeOnly) || false,
         allowCredentials: (opts == null ? void 0 : opts.allowCredentials) || false
       }
     };
-    return this.cloneWithRules([{ flag: "uri", constraint }]);
+    return this.cloneWithRules([{
+      flag: "uri",
+      constraint
+    }]);
   }
+
   unique() {
-    return this.cloneWithRules([{ flag: "unique" }]);
+    return this.cloneWithRules([{
+      flag: "unique"
+    }]);
   }
+
   reference() {
-    return this.cloneWithRules([{ flag: "reference" }]);
+    return this.cloneWithRules([{
+      flag: "reference"
+    }]);
   }
+
   fields(rules) {
     if (this._type !== "Object") {
       throw new Error("fields() can only be called on an object type");
     }
+
     const rule = this.cloneWithRules([]);
     rule._fieldRules = rules;
     return rule;
   }
+
   assetRequired() {
     const base = getBaseType(this._typeDef);
     let assetType;
+
     if (base && ["image", "file"].includes(base.name)) {
       assetType = base.name === "image" ? "Image" : "File";
     } else {
       assetType = "Asset";
     }
-    return this.cloneWithRules([{ flag: "assetRequired", constraint: { assetType } }]);
+
+    return this.cloneWithRules([{
+      flag: "assetRequired",
+      constraint: {
+        assetType
+      }
+    }]);
   }
+
   async validate(value, context) {
     if (!context) {
       throw new Error("missing context");
     }
+
     const valueIsEmpty = value === null || value === void 0;
+
     if (valueIsEmpty && this._required === "optional") {
       return EMPTY_ARRAY;
     }
-    const rules = this._required === void 0 && valueIsEmpty ? this._rules.filter((curr) => curr.flag === "custom") : this._rules;
+
+    const rules = this._required === void 0 && valueIsEmpty ? this._rules.filter(curr => curr.flag === "custom") : this._rules;
     const validators = this._type && typeValidators[this._type] || genericValidators;
-    const results = await Promise.all(
-      rules.map(async (curr) => {
-        if (curr.flag === void 0) {
-          throw new Error('Invalid rule, did not contain "flag"-property');
-        }
-        const validator = validators[curr.flag];
-        if (!validator) {
-          const forType = this._type ? `type "${this._type}"` : "rule without declared type";
-          throw new Error(`Validator for flag "${curr.flag}" not found for ${forType}`);
-        }
-        let specConstraint = "constraint" in curr ? curr.constraint : null;
-        if (isFieldRef(specConstraint)) {
-          specConstraint = get(context.parent, specConstraint.path);
-        }
-        let result;
-        try {
-          result = await validator(specConstraint, value, this._message, context);
-        } catch (err) {
-          const errorFromException = new ValidationError(
-            `${pathToString(context.path)}: Exception occurred while validating value: ${err.message}`
-          );
-          return convertToValidationMarker(errorFromException, "error", context);
-        }
-        return convertToValidationMarker(result, this._level, context);
-      })
-    );
+    const results = await Promise.all(rules.map(async curr => {
+      if (curr.flag === void 0) {
+        throw new Error('Invalid rule, did not contain "flag"-property');
+      }
+
+      const validator = validators[curr.flag];
+
+      if (!validator) {
+        const forType = this._type ? "type \"".concat(this._type, "\"") : "rule without declared type";
+        throw new Error("Validator for flag \"".concat(curr.flag, "\" not found for ").concat(forType));
+      }
+
+      let specConstraint = "constraint" in curr ? curr.constraint : null;
+
+      if (isFieldRef(specConstraint)) {
+        specConstraint = get(context.parent, specConstraint.path);
+      }
+
+      let result;
+
+      try {
+        result = await validator(specConstraint, value, this._message, context);
+      } catch (err) {
+        const errorFromException = new ValidationError("".concat(pathToString(context.path), ": Exception occurred while validating value: ").concat(err.message));
+        return convertToValidationMarker(errorFromException, "error", context);
+      }
+
+      return convertToValidationMarker(result, this._level, context);
+    }));
     return results.flat();
   }
-}, _a.FIELD_REF = FIELD_REF, _a.array = (def) => new _a(def).type("Array"), _a.object = (def) => new _a(def).type("Object"), _a.string = (def) => new _a(def).type("String"), _a.number = (def) => new _a(def).type("Number"), _a.boolean = (def) => new _a(def).type("Boolean"), _a.dateTime = (def) => new _a(def).type("Date"), _a.valueOfField = (path) => ({
+
+}, _a.FIELD_REF = FIELD_REF, _a.array = def => new _a(def).type("Array"), _a.object = def => new _a(def).type("Object"), _a.string = def => new _a(def).type("String"), _a.number = def => new _a(def).type("Number"), _a.boolean = def => new _a(def).type("Boolean"), _a.dateTime = def => new _a(def).type("Date"), _a.valueOfField = path => ({
   type: FIELD_REF,
   path
 }), _a);
-
 const memoizedWarnOnArraySlug = memoize(warnOnArraySlug);
+
 function getDocumentIds(id) {
   const isDraft = id.indexOf("drafts.") === 0;
   return {
     published: isDraft ? id.slice("drafts.".length) : id,
-    draft: isDraft ? id : `drafts.${id}`
+    draft: isDraft ? id : "drafts.".concat(id)
   };
 }
+
 function serializePath(path) {
   return path.reduce((target, part, i) => {
     const isIndex = typeof part === "number";
     const isKey = isKeyedObject(part);
     const separator = i === 0 ? "" : ".";
-    const add = isIndex || isKey ? "[]" : `${separator}${part}`;
-    return `${target}${add}`;
+    const add = isIndex || isKey ? "[]" : "".concat(separator).concat(part);
+    return "".concat(target).concat(add);
   }, "");
 }
+
 const defaultIsUnique = (slug, context) => {
-  const { client, document, path, type } = context;
+  const {
+    client,
+    document,
+    path,
+    type
+  } = context;
   const schemaOptions = type == null ? void 0 : type.options;
+
   if (!document) {
-    throw new Error(`\`document\` was not provided in validation context.`);
+    throw new Error("`document` was not provided in validation context.");
   }
+
   if (!path) {
-    throw new Error(`\`path\` was not provided in validation context.`);
+    throw new Error("`path` was not provided in validation context.");
   }
+
   const disableArrayWarning = (schemaOptions == null ? void 0 : schemaOptions.disableArrayWarning) || false;
-  const { published, draft } = getDocumentIds(document._id);
+  const {
+    published,
+    draft
+  } = getDocumentIds(document._id);
   const docType = document._type;
   const atPath = serializePath(path.concat("current"));
+
   if (!disableArrayWarning && atPath.includes("[]")) {
     memoizedWarnOnArraySlug(serializePath(path));
   }
-  const constraints = [
-    "_type == $docType",
-    `!(_id in [$draft, $published])`,
-    `${atPath} == $slug`
-  ].join(" && ");
-  return client.fetch(
-    `!defined(*[${constraints}][0]._id)`,
-    {
-      docType,
-      draft,
-      published,
-      slug
-    },
-    { tag: "validation.slug-is-unique" }
-  );
+
+  const constraints = ["_type == $docType", "!(_id in [$draft, $published])", "".concat(atPath, " == $slug")].join(" && ");
+  return client.fetch("!defined(*[".concat(constraints, "][0]._id)"), {
+    docType,
+    draft,
+    published,
+    slug
+  }, {
+    tag: "validation.slug-is-unique"
+  });
 };
+
 function warnOnArraySlug(serializedPath) {
-  console.warn(
-    [
-      `Slug field at path ${serializedPath} is within an array and cannot be automatically checked for uniqueness`,
-      `If you need to check for uniqueness, provide your own "isUnique" method`,
-      `To disable this message, set \`disableArrayWarning: true\` on the slug \`options\` field`
-    ].join("\n")
-  );
+  console.warn(["Slug field at path ".concat(serializedPath, " is within an array and cannot be automatically checked for uniqueness"), "If you need to check for uniqueness, provide your own \"isUnique\" method", "To disable this message, set `disableArrayWarning: true` on the slug `options` field"].join("\n"));
 }
+
 const slugValidator = async (value, context) => {
   var _a;
+
   if (!value) {
     return true;
   }
+
   if (typeof value !== "object") {
     return "Slug must be an object";
   }
+
   const slugValue = value.current;
+
   if (!slugValue) {
     return "Slug must have a value";
   }
+
   const options = (_a = context == null ? void 0 : context.type) == null ? void 0 : _a.options;
   const isUnique = (options == null ? void 0 : options.isUnique) || defaultIsUnique;
-  const wasUnique = await isUnique(slugValue, { ...context, defaultIsUnique });
+  const wasUnique = await isUnique(slugValue, _objectSpread(_objectSpread({}, context), {}, {
+    defaultIsUnique
+  }));
+
   if (wasUnique) {
     return true;
   }
+
   return "Slug is already in use";
 };
 
@@ -950,112 +1216,117 @@ const ruleConstraintTypes = {
   object: true,
   string: true
 };
-const isRuleConstraint = (typeString) => typeString in ruleConstraintTypes;
+
+const isRuleConstraint = typeString => typeString in ruleConstraintTypes;
+
 function getTypeChain(type, visited) {
-  if (!type)
-    return [];
-  if (visited.has(type))
-    return [];
+  if (!type) return [];
+  if (visited.has(type)) return [];
   visited.add(type);
   const next = type.type ? getTypeChain(type.type, visited) : [];
   return [...next, type];
 }
+
 function baseRuleReducer(inputRule, type) {
   let baseRule = inputRule;
+
   if (isRuleConstraint(type.jsonType)) {
     baseRule = baseRule.type(type.jsonType);
   }
+
   const typeOptionsList = (type == null ? void 0 : type.options) && typeof type.options === "object" && "list" in type.options && type.options.list;
+
   if (Array.isArray(typeOptionsList)) {
-    baseRule = baseRule.valid(
-      typeOptionsList.map((option) => extractValueFromListOption(option, type))
-    );
-  }
-  if (type.name === "datetime")
-    return baseRule.type("Date");
-  if (type.name === "date")
-    return baseRule.type("Date");
-  if (type.name === "url")
-    return baseRule.uri();
-  if (type.name === "slug")
-    return baseRule.custom(slugValidator);
-  if (type.name === "reference")
-    return baseRule.reference();
-  if (type.name === "email")
-    return baseRule.email();
+    baseRule = baseRule.valid(typeOptionsList.map(option => extractValueFromListOption(option, type)));
+  }
+
+  if (type.name === "datetime") return baseRule.type("Date");
+  if (type.name === "date") return baseRule.type("Date");
+  if (type.name === "url") return baseRule.uri();
+  if (type.name === "slug") return baseRule.custom(slugValidator);
+  if (type.name === "reference") return baseRule.reference();
+  if (type.name === "email") return baseRule.email();
   return baseRule;
 }
+
 function hasValueField(typeDef) {
-  if (!typeDef)
-    return false;
-  if (!("fields" in typeDef) && typeDef.type)
-    return hasValueField(typeDef.type);
-  if (!("fields" in typeDef))
-    return false;
-  if (!Array.isArray(typeDef.fields))
-    return false;
-  return typeDef.fields.some((field) => field.name === "value");
+  if (!typeDef) return false;
+  if (!("fields" in typeDef) && typeDef.type) return hasValueField(typeDef.type);
+  if (!("fields" in typeDef)) return false;
+  if (!Array.isArray(typeDef.fields)) return false;
+  return typeDef.fields.some(field => field.name === "value");
 }
+
 function extractValueFromListOption(option, typeDef) {
-  if (typeDef.jsonType === "object" && hasValueField(typeDef))
-    return option;
+  if (typeDef.jsonType === "object" && hasValueField(typeDef)) return option;
   return option.value === void 0 ? option : option.value;
 }
+
 function normalizeValidationRules(typeDef) {
   if (!typeDef) {
     return [];
   }
+
   const validation = typeDef.validation;
+
   if (Array.isArray(validation)) {
-    return validation.flatMap(
-      (i) => normalizeValidationRules({
-        ...typeDef,
-        validation: i
-      })
-    );
+    return validation.flatMap(i => normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
+      validation: i
+    })));
   }
+
   if (validation instanceof Rule) {
     return [validation];
   }
-  const baseRule = Object.values(
-    getTypeChain(typeDef, /* @__PURE__ */ new Set()).reduce((acc, type) => {
-      acc[type.name] = type;
-      return acc;
-    }, {})
-  ).reduce(baseRuleReducer, new Rule(typeDef));
+
+  const baseRule = Object.values(getTypeChain(typeDef, /* @__PURE__ */new Set()).reduce((acc, type) => {
+    acc[type.name] = type;
+    return acc;
+  }, {})).reduce(baseRuleReducer, new Rule(typeDef));
+
   if (!validation) {
     return [baseRule];
   }
-  return normalizeValidationRules({
-    ...typeDef,
+
+  return normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
     validation: validation(baseRule)
-  });
+  }));
 }
 
-const isRecord = (maybeRecord) => typeof maybeRecord === "object" && maybeRecord !== null && !Array.isArray(maybeRecord);
-const isNonNullable = (value) => value !== null && value !== void 0;
+const isRecord = maybeRecord => typeof maybeRecord === "object" && maybeRecord !== null && !Array.isArray(maybeRecord);
+
+const isNonNullable = value => value !== null && value !== void 0;
+
 function resolveTypeForArrayItem(item, candidates) {
-  if (candidates.length === 1)
-    return candidates[0];
+  if (candidates.length === 1) return candidates[0];
+
   const itemType = isTypedObject(item) && item._type;
+
   const primitive = item === void 0 || item === null || !itemType && typeString(item).toLowerCase();
+
   if (primitive && primitive !== "object") {
-    return candidates.find((candidate) => candidate.jsonType === primitive);
+    return candidates.find(candidate => candidate.jsonType === primitive);
   }
-  return candidates.find((candidate) => {
+
+  return candidates.find(candidate => {
     var _a;
+
     return ((_a = candidate.type) == null ? void 0 : _a.name) === itemType;
-  }) || candidates.find((candidate) => candidate.name === itemType) || candidates.find((candidate) => candidate.name === "object" && primitive === "object");
+  }) || candidates.find(candidate => candidate.name === itemType) || candidates.find(candidate => candidate.name === "object" && primitive === "object");
 }
+
 async function validateDocument(client, doc, schema, context) {
   const documentType = schema.get(doc._type);
+
   if (!documentType) {
     console.warn('Schema type for object type "%s" not found, skipping validation', doc._type);
     return [];
   }
+
   try {
     return await validateItem({
       client,
+      schema,
       parent: void 0,
       value: doc,
       path: [],
@@ -1065,106 +1336,98 @@ async function validateDocument(client, doc, schema, context) {
     });
   } catch (err) {
     console.error(err);
-    return [
-      {
-        level: "error",
-        path: [],
-        item: new ValidationError(err == null ? void 0 : err.message)
-      }
-    ];
+    return [{
+      level: "error",
+      path: [],
+      item: new ValidationError(err == null ? void 0 : err.message)
+    }];
   }
 }
-async function validateItem({
-  value,
-  type,
-  path = [],
-  parent,
-  ...restOfContext
-}) {
+
+async function validateItem(_ref) {
+  let {
+    value,
+    type,
+    path = [],
+    parent
+  } = _ref,
+      restOfContext = _objectWithoutProperties(_ref, _excluded);
+
   const rules = normalizeValidationRules(type);
-  const selfChecks = rules.map(
-    (rule) => rule.validate(value, {
-      ...restOfContext,
-      parent,
-      path,
-      type
-    })
-  );
+  const selfChecks = rules.map(rule => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
+    parent,
+    path,
+    type
+  })));
   let nestedChecks = [];
-  const selfIsRequired = rules.some((rule) => rule.isRequired());
+  const selfIsRequired = rules.some(rule => rule.isRequired());
   const shouldRunNestedObjectValidation = (type == null ? void 0 : type.jsonType) === "object" && (!!value || (value === null || value === void 0) && selfIsRequired);
+
   if (shouldRunNestedObjectValidation) {
     const fieldTypes = type.fields.reduce((acc, field) => {
       acc[field.name] = field.type;
       return acc;
     }, {});
-    nestedChecks = nestedChecks.concat(
-      rules.map((rule) => rule._fieldRules).filter(isNonNullable).flatMap((fieldResults) => Object.entries(fieldResults)).flatMap(([name, validation]) => {
-        const fieldType = fieldTypes[name];
-        return normalizeValidationRules({ ...fieldType, validation }).map((subRule) => {
-          const nestedValue = isRecord(value) ? value[name] : void 0;
-          return subRule.validate(nestedValue, {
-            ...restOfContext,
-            parent: value,
-            path: path.concat(name),
-            type: fieldType
-          });
-        });
-      })
-    );
-    nestedChecks = nestedChecks.concat(
-      type.fields.map(
-        (field) => validateItem({
-          ...restOfContext,
+    nestedChecks = nestedChecks.concat(rules.map(rule => rule._fieldRules).filter(isNonNullable).flatMap(fieldResults => Object.entries(fieldResults)).flatMap(_ref2 => {
+      let [name, validation] = _ref2;
+      const fieldType = fieldTypes[name];
+      return normalizeValidationRules(_objectSpread(_objectSpread({}, fieldType), {}, {
+        validation
+      })).map(subRule => {
+        const nestedValue = isRecord(value) ? value[name] : void 0;
+        return subRule.validate(nestedValue, _objectSpread(_objectSpread({}, restOfContext), {}, {
           parent: value,
-          value: isRecord(value) ? value[field.name] : void 0,
-          path: path.concat(field.name),
-          type: field.type
-        })
-      )
-    );
+          path: path.concat(name),
+          type: fieldType
+        }));
+      });
+    }));
+    nestedChecks = nestedChecks.concat(type.fields.map(field => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
+      parent: value,
+      value: isRecord(value) ? value[field.name] : void 0,
+      path: path.concat(field.name),
+      type: field.type
+    }))));
   }
+
   const shouldRunNestedValidationForArrays = (type == null ? void 0 : type.jsonType) === "array" && Array.isArray(value);
+
   if (shouldRunNestedValidationForArrays) {
-    nestedChecks = nestedChecks.concat(
-      value.map(
-        (item) => validateItem({
-          ...restOfContext,
-          parent: value,
-          value: item,
-          path: path.concat(isKeyedObject(item) ? { _key: item._key } : value.indexOf(item)),
-          type: resolveTypeForArrayItem(item, type.of)
-        })
-      )
-    );
+    nestedChecks = nestedChecks.concat(value.map(item => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
+      parent: value,
+      value: item,
+      path: path.concat(isKeyedObject(item) ? {
+        _key: item._key
+      } : value.indexOf(item)),
+      type: resolveTypeForArrayItem(item, type.of)
+    }))));
   }
+
   const shouldRunNestedValidationForMarkDefs = isBlock(value) && value.markDefs.length && isBlockSchemaType(type);
+
   if (shouldRunNestedValidationForMarkDefs) {
     const [spanChildrenField] = type.fields;
     const spanType = spanChildrenField.type.of.find(isSpanSchemaType);
-    const annotations = ((spanType == null ? void 0 : spanType.annotations) || []).reduce(
-      (map, annotationType) => {
-        map.set(annotationType.name, annotationType);
-        return map;
-      },
-      /* @__PURE__ */ new Map()
-    );
-    nestedChecks = nestedChecks.concat(
-      value.markDefs.map(
-        (markDef) => validateItem({
-          ...restOfContext,
-          parent: value,
-          value: markDef,
-          path: path.concat(["markDefs", { _key: markDef._key }]),
-          type: annotations.get(markDef._type)
-        })
-      )
-    );
+    const annotations = ((spanType == null ? void 0 : spanType.annotations) || []).reduce((map, annotationType) => {
+      map.set(annotationType.name, annotationType);
+      return map;
+    }, /* @__PURE__ */new Map());
+    nestedChecks = nestedChecks.concat(value.markDefs.map(markDef => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
+      parent: value,
+      value: markDef,
+      path: path.concat(["markDefs", {
+        _key: markDef._key
+      }]),
+      type: annotations.get(markDef._type)
+    }))));
   }
+
   const results = (await Promise.all([...selfChecks, ...nestedChecks])).flat();
-  if (rules.some((rule) => rule._fieldRules)) {
-    return uniqBy(results, (rule) => JSON.stringify(rule));
+
+  if (rules.some(rule => rule._fieldRules)) {
+    return uniqBy(results, rule => JSON.stringify(rule));
   }
+
   return results;
 }
 
@@ -1172,33 +1435,39 @@ function traverse(typeDef, visited) {
   if (visited.has(typeDef)) {
     return;
   }
+
   visited.add(typeDef);
   typeDef.validation = normalizeValidationRules(typeDef);
+
   if ("fields" in typeDef) {
     for (const field of typeDef.fields) {
       traverse(field.type, visited);
     }
   }
+
   if ("of" in typeDef) {
     for (const candidate of typeDef.of) {
       traverse(candidate, visited);
     }
   }
+
   if (typeDef.annotations) {
     for (const annotation of typeDef.annotations) {
       traverse(annotation, visited);
     }
   }
 }
+
 function inferFromSchemaType(typeDef) {
-  traverse(typeDef, /* @__PURE__ */ new Set());
+  traverse(typeDef, /* @__PURE__ */new Set());
   return typeDef;
 }
 
 function inferFromSchema(schema) {
   const typeNames = schema.getTypeNames();
-  typeNames.forEach((typeName) => {
+  typeNames.forEach(typeName => {
     const schemaType = schema.get(typeName);
+
     if (schemaType) {
       inferFromSchemaType(schemaType);
     }