@sanity/validation 3.0.0-dev-preview.22 → 3.0.0-findability.53

package/lib/index.js

@@ -1,25 +1,39 @@
 'use strict';
 
 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; }
+
 Object.defineProperty(exports, '__esModule', {
   value: true
 });
+
 var lodash = require('lodash');
+
 var types = require('@sanity/types');
+
 var formatDate = require('date-fns/format');
+
 var rxjs = require('rxjs');
+
 var operators = require('rxjs/operators');
+
 function _interopDefaultLegacy(e) {
   return e && typeof e === 'object' && 'default' in e ? e : {
     'default': e
   };
 }
+
 var formatDate__default = /*#__PURE__*/_interopDefaultLegacy(formatDate);
+
 const ValidationError = class ValidationError2 {
   constructor(message) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -28,6 +42,7 @@ const ValidationError = class ValidationError2 {
     this.children = options.children;
     this.operation = options.operation;
   }
+
   cloneWithMessage(msg) {
     return new ValidationError2(msg, {
       paths: this.paths,
@@ -35,49 +50,66 @@ const ValidationError = class ValidationError2 {
       operation: this.operation
     });
   }
+
 };
+
 var escapeRegex = string => {
   return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, "\\$&");
 };
+
 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 "".concat(target, "[").concat(segment, "]");
     }
+
     if (segmentType === "string") {
       const separator = i === 0 ? "" : ".";
       return "".concat(target).concat(separator).concat(segment);
     }
+
     if (types.isKeyedObject(segment)) {
       return "".concat(target, "[_key==\"").concat(segment._key, "\"]");
     }
+
     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 (Array.isArray(validatorResult)) {
     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("".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",
@@ -85,85 +117,113 @@ function convertToValidationMarker(validatorResult, level, context) {
       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;
   }
+
   return false;
 }
+
 function typeString(obj) {
   const stringType = _toString.call(obj).slice(8, -1);
+
   if (obj === null || obj === void 0) return stringType.toLowerCase();
   const constructorType = obj.constructor;
   if (constructorType && !isBuiltIn(constructorType)) return constructorType.name;
   return stringType;
 }
+
 function deepEquals(a, b) {
   if (a === b) {
     return true;
   }
+
   if (Array.isArray(a) && Array.isArray(b)) {
     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 => {
   var _a;
+
   let message;
+
   if (options.message) {
     message = options.message;
   } else if (options.results.length === 1) {
@@ -171,23 +231,28 @@ const formatValidationErrors = options => {
   } else {
     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 \"".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) => {
@@ -212,9 +277,11 @@ const genericValidators = {
   },
   valid: (allowedValues, actual, message) => {
     const valueType = typeof actual;
+
     if (valueType === "undefined") {
       return true;
     }
+
     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";
@@ -225,86 +292,106 @@ const genericValidators = {
       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;
     return result;
   }
 };
+
 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 = _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;
     const places = value.toString().match(precisionRx);
     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 ".concat(limit);
     }
+
     return true;
   },
   min: (minNum, value, message) => {
     if (value >= minNum) {
       return true;
     }
+
     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 ".concat(maxNum);
   },
   greaterThan: (num, value, message) => {
     if (value > num) {
       return true;
     }
+
     return message || "Must be greater than ".concat(num);
   },
   lessThan: (maxNum, value, message) => {
     if (value < maxNum) {
       return true;
     }
+
     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 = _objectSpread(_objectSpread({}, genericValidators), {}, {
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
     }
+
     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 ".concat(maxLength, " characters long");
   },
   length: (wantedLength, value, message) => {
     const strValue = value || "";
+
     if (strValue.length === wantedLength) {
       return true;
     }
+
     return message || "Must be exactly ".concat(wantedLength, " characters long");
   },
   uri: (constraints, value, message) => {
@@ -318,41 +405,52 @@ const stringValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     } = 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";
     }
+
     const urlScheme = url.protocol.replace(/:$/, "");
     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";
     }
+
     if (casing === "lowercase" && strValue !== strValue.toLocaleLowerCase()) {
       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) => {
@@ -364,85 +462,106 @@ const stringValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     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 ".concat(regName, "-pattern") : "Does not match ".concat(regName, "-pattern");
       return message || defaultMessage;
     }
+
     return true;
   },
   email: (_unused, value, message) => {
     const strValue = "".concat(value || "").trim();
+
     if (!strValue || emailRegex.test(strValue)) {
       return true;
     }
+
     return message || "Must be a valid email address";
   }
 });
+
 const arrayValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
     }
+
     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 ".concat(maxLength, " items");
   },
   length: (wantedLength, value, message) => {
     if (!value || value.length === wantedLength) {
       return true;
     }
+
     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))) {
         continue;
       }
+
       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
     });
   },
   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 item = value[idx];
       const pathSegment = item && item._key ? {
@@ -455,44 +574,57 @@ const arrayValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     }) : true;
   }
 });
+
 const metaKeys = ["_key", "_type", "_weak"];
+
 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));
+
     if (value === void 0 || keys && keys.length === 0) {
       return message || "Required";
     }
+
     return true;
   },
   reference: async (_unused, value, message, context) => {
     if (!value) {
       return true;
     }
+
     if (!types.isReference(value)) {
       return message || true;
     }
+
     const {
       type,
       getDocumentExists
     } = context;
+
     if (!type) {
       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");
     }
+
     const exists = await getDocumentExists({
       id: value._ref
     });
+
     if (!exists) {
       return "This reference must be published";
     }
+
     return true;
   },
   assetRequired: (flag, value, message) => {
@@ -500,82 +632,106 @@ const objectValidators = _objectSpread(_objectSpread({}, genericValidators), {},
       const assetType = flag.assetType || "Asset";
       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 = 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__default["default"](new Date(value), format);
   }
+
   if (options && options.timeFormat) {
     format += " ".concat(options.timeFormat);
   } else {
     format += " HH:mm";
   }
+
   return formatDate__default["default"](new Date(value), format);
 };
+
 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 \"".concat(date, "\" to a date"));
   }
+
   return isInvalid ? null : parsed;
 }
+
 const dateValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
   type: (_unused, value, message) => {
     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.");
     }
+
     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 ".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.");
     }
+
     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 ".concat(date);
   }
 });
+
 var _a;
+
 const typeValidators = {
   Boolean: booleanValidators,
   Number: numberValidators,
@@ -584,13 +740,16 @@ const typeValidators = {
   Object: objectValidators,
   Date: dateValidators
 };
+
 const getBaseType = type => {
   return type && type.type ? getBaseType(type.type) : type;
 };
+
 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"];
@@ -607,29 +766,34 @@ 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";
     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");
@@ -639,9 +803,11 @@ const Rule = (_a = class {
     this._fieldRules = void 0;
     return this;
   }
+
   isRequired() {
     return this._required === "required";
   }
+
   clone() {
     const rule = new _a();
     rule._type = this._type;
@@ -653,6 +819,7 @@ const Rule = (_a = class {
     rule._typeDef = this._typeDef;
     return rule;
   }
+
   cloneWithRules(rules) {
     const rule = this.clone();
     const newRules = /* @__PURE__ */new Set();
@@ -660,6 +827,7 @@ const Rule = (_a = class {
       if (curr.flag === "type") {
         rule._type = curr.constraint;
       }
+
       newRules.add(curr.flag);
     });
     rule._rules = rule._rules.filter(curr => {
@@ -669,10 +837,12 @@ const Rule = (_a = class {
     }).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;
@@ -680,11 +850,14 @@ const Rule = (_a = class {
     newRule._level = this._level === "error" ? rule._level : this._level;
     return newRule;
   }
+
   type(targetType) {
     const type = "".concat(targetType.slice(0, 1).toUpperCase()).concat(targetType.slice(1));
+
     if (!ruleConstraintTypes$1.includes(type)) {
       throw new Error("Unknown type \"".concat(targetType, "\""));
     }
+
     const rule = this.cloneWithRules([{
       flag: "type",
       constraint: type
@@ -692,18 +865,21 @@ const Rule = (_a = class {
     rule._type = type;
     return rule;
   }
+
   all(children) {
     return this.cloneWithRules([{
       flag: "all",
       constraint: children
     }]);
   }
+
   either(children) {
     return this.cloneWithRules([{
       flag: "either",
       constraint: children
     }]);
   }
+
   optional() {
     const rule = this.cloneWithRules([{
       flag: "presence",
@@ -712,6 +888,7 @@ const Rule = (_a = class {
     rule._required = "optional";
     return rule;
   }
+
   required() {
     const rule = this.cloneWithRules([{
       flag: "presence",
@@ -720,36 +897,42 @@ const Rule = (_a = class {
     rule._required = "required";
     return rule;
   }
+
   custom(fn) {
     return this.cloneWithRules([{
       flag: "custom",
       constraint: fn
     }]);
   }
+
   block(fn) {
     return this.cloneWithRules([{
       flag: "custom",
       constraint: fn
     }]);
   }
+
   min(len) {
     return this.cloneWithRules([{
       flag: "min",
       constraint: len
     }]);
   }
+
   max(len) {
     return this.cloneWithRules([{
       flag: "max",
       constraint: len
     }]);
   }
+
   length(len) {
     return this.cloneWithRules([{
       flag: "length",
       constraint: len
     }]);
   }
+
   valid(value) {
     const values = Array.isArray(value) ? value : [value];
     return this.cloneWithRules([{
@@ -757,55 +940,65 @@ const Rule = (_a = class {
       constraint: values
     }]);
   }
+
   integer() {
     return this.cloneWithRules([{
       flag: "integer"
     }]);
   }
+
   precision(limit) {
     return this.cloneWithRules([{
       flag: "precision",
       constraint: limit
     }]);
   }
+
   positive() {
     return this.cloneWithRules([{
       flag: "min",
       constraint: 0
     }]);
   }
+
   negative() {
     return this.cloneWithRules([{
       flag: "lessThan",
       constraint: 0
     }]);
   }
+
   greaterThan(num) {
     return this.cloneWithRules([{
       flag: "greaterThan",
       constraint: num
     }]);
   }
+
   lessThan(num) {
     return this.cloneWithRules([{
       flag: "lessThan",
       constraint: num
     }]);
   }
+
   uppercase() {
     return this.cloneWithRules([{
       flag: "stringCasing",
       constraint: "uppercase"
     }]);
   }
+
   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 = {
@@ -818,23 +1011,28 @@ const Rule = (_a = class {
       constraint
     }]);
   }
+
   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 => {
           if (!(scheme instanceof RegExp) && typeof scheme !== "string") {
             throw new Error("scheme must be a RegExp or a String");
           }
+
           return typeof scheme === "string" ? new RegExp("^".concat(escapeRegex(scheme), "$")) : scheme;
         }),
         allowRelative: (opts == null ? void 0 : opts.allowRelative) || false,
@@ -847,32 +1045,39 @@ const Rule = (_a = class {
       constraint
     }]);
   }
+
   unique() {
     return this.cloneWithRules([{
       flag: "unique"
     }]);
   }
+
   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: {
@@ -880,62 +1085,80 @@ const Rule = (_a = class {
       }
     }]);
   }
+
   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 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 \"".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 = lodash.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 => ({
   type: FIELD_REF,
   path
 }), _a);
+
 const requestIdleCallbackShim = function requestIdleCallbackShim2(callback, options) {
   const start = Date.now();
   return window.setTimeout(() => {
     callback({
       didTimeout: false,
+
       timeRemaining() {
         return Math.max(0, Date.now() - start);
       }
+
     });
   }, 0);
 };
+
 const cancelIdleCallbackShim = function cancelIdleCallbackShim2(handle) {
   return window.clearTimeout(handle);
 };
+
 const win = typeof window === "undefined" ? void 0 : window;
 const requestIdleCallback = (win == null ? void 0 : win.requestIdleCallback) || requestIdleCallbackShim;
 const cancelIdleCallback = (win == null ? void 0 : win.cancelIdleCallback) || cancelIdleCallbackShim;
 const memoizedWarnOnArraySlug = lodash.memoize(warnOnArraySlug);
+
 function getDocumentIds(id) {
   const isDraft = id.indexOf("drafts.") === 0;
   return {
@@ -943,6 +1166,7 @@ function getDocumentIds(id) {
     draft: isDraft ? id : "drafts.".concat(id)
   };
 }
+
 function serializePath(path) {
   return path.reduce((target, part, i) => {
     const isIndex = typeof part === "number";
@@ -952,6 +1176,7 @@ function serializePath(path) {
     return "".concat(target).concat(add);
   }, "");
 }
+
 const defaultIsUnique = (slug, context) => {
   const {
     getClient,
@@ -960,12 +1185,15 @@ const defaultIsUnique = (slug, context) => {
     type
   } = context;
   const schemaOptions = type == null ? void 0 : type.options;
+
   if (!document) {
     throw new Error("`document` was not provided in validation context.");
   }
+
   if (!path) {
     throw new Error("`path` was not provided in validation context.");
   }
+
   const disableArrayWarning = (schemaOptions == null ? void 0 : schemaOptions.disableArrayWarning) || false;
   const {
     published,
@@ -973,9 +1201,11 @@ const defaultIsUnique = (slug, context) => {
   } = 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])", "".concat(atPath, " == $slug")].join(" && ");
   return getClient({
     apiVersion: "2022-09-09"
@@ -988,34 +1218,46 @@ const defaultIsUnique = (slug, context) => {
     tag: "validation.slug-is-unique"
   });
 };
+
 function warnOnArraySlug(serializedPath) {
   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 slugContext = _objectSpread(_objectSpread({}, context), {}, {
     parent: context.parent,
     type: context.type,
     defaultIsUnique
   });
+
   const wasUnique = await isUnique(slugValue, slugContext);
+
   if (wasUnique) {
     return true;
   }
+
   return "Slug is already in use";
 };
+
 const ruleConstraintTypes = {
   array: true,
   boolean: true,
@@ -1024,7 +1266,9 @@ const ruleConstraintTypes = {
   object: true,
   string: true
 };
+
 const isRuleConstraint = typeString => typeString in ruleConstraintTypes;
+
 function getTypeChain(type, visited) {
   if (!type) return [];
   if (visited.has(type)) return [];
@@ -1032,15 +1276,20 @@ function getTypeChain(type, visited) {
   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();
@@ -1049,6 +1298,7 @@ function baseRuleReducer(inputRule, type) {
   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);
@@ -1056,58 +1306,79 @@ function hasValueField(typeDef) {
   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;
   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(_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));
+
   if (!validation) {
     return [baseRule];
   }
+
   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;
+
 function resolveTypeForArrayItem(item, candidates) {
   if (candidates.length === 1) return candidates[0];
+
   const itemType = types.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 => {
     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");
 }
+
 const EMPTY_MARKERS = [];
+
 async function validateDocument(getClient, doc, schema, context) {
   return validateDocumentObservable(getClient, doc, schema, context).toPromise();
 }
+
 function validateDocumentObservable(getClient, 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 rxjs.of(EMPTY_MARKERS);
   }
+
   const client = getClient({
     apiVersion: "2021-06-07"
   });
@@ -1130,6 +1401,7 @@ function validateDocumentObservable(getClient, doc, schema, context) {
         console.warn('`configContext.client` is deprecated and will be removed in the next release! Use `context.getClient({apiVersion: "2021-06-07"})` instead');
         return original;
       }
+
     });
   }, {});
   return validateItemObservable(validationOptions).pipe(operators.catchError(err => {
@@ -1142,14 +1414,16 @@ function validateDocumentObservable(getClient, doc, schema, context) {
     }]);
   }));
 }
+
 function validateItemObservable(_ref) {
   let {
-      value,
-      type,
-      path = [],
-      parent
-    } = _ref,
-    restOfContext = _objectWithoutProperties(_ref, _excluded);
+    value,
+    type,
+    path = [],
+    parent
+  } = _ref,
+      restOfContext = _objectWithoutProperties(_ref, _excluded);
+
   const rules = normalizeValidationRules(type);
   const selfChecks = rules.map(rule => rxjs.defer(() => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
     parent,
@@ -1159,6 +1433,7 @@ function validateItemObservable(_ref) {
   let nestedChecks = [];
   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;
@@ -1185,7 +1460,9 @@ function validateItemObservable(_ref) {
       type: field.type
     }))));
   }
+
   const shouldRunNestedValidationForArrays = (type == null ? void 0 : type.jsonType) === "array" && Array.isArray(value);
+
   if (shouldRunNestedValidationForArrays) {
     nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
       parent: value,
@@ -1196,7 +1473,9 @@ function validateItemObservable(_ref) {
       type: resolveTypeForArrayItem(item, type.of)
     }))));
   }
+
   const shouldRunNestedValidationForMarkDefs = types.isBlock(value) && value.markDefs.length && types.isBlockSchemaType(type);
+
   if (shouldRunNestedValidationForMarkDefs) {
     const [spanChildrenField] = type.fields;
     const spanType = spanChildrenField.type.of.find(types.isSpanSchemaType);
@@ -1213,13 +1492,16 @@ function validateItemObservable(_ref) {
       type: annotations.get(markDef._type)
     }))));
   }
+
   return rxjs.defer(() => rxjs.merge([...selfChecks, ...nestedChecks])).pipe(operators.mergeMap(validateNode => rxjs.concat(idle(), validateNode), 40), operators.mergeAll(), operators.toArray(), operators.map(lodash.flatten), operators.map(results => {
     if (rules.some(rule => rule._fieldRules)) {
       return lodash.uniqBy(results, rule => JSON.stringify(rule));
     }
+
     return results;
   }));
 }
+
 function idle(timeout) {
   return new rxjs.Observable(observer => {
     const handle = requestIdleCallback(() => {
@@ -1230,42 +1512,51 @@ function idle(timeout) {
     return () => cancelIdleCallback(handle);
   });
 }
+
 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());
   return typeDef;
 }
+
 function inferFromSchema(schema) {
   const typeNames = schema.getTypeNames();
   typeNames.forEach(typeName => {
     const schemaType = schema.get(typeName);
+
     if (schemaType) {
       inferFromSchemaType(schemaType);
     }
   });
   return schema;
 }
+
 exports.Rule = Rule;
 exports.inferFromSchema = inferFromSchema;
 exports.inferFromSchemaType = inferFromSchemaType;