@sanity/validation 2.34.1-canary.0 → 2.34.2-empty-template-cli.0

package/lib/util/convertToValidationMarker.js

@@ -5,36 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = convertToValidationMarker;
 exports.isNonNullable = isNonNullable;
+
 var _ValidationError = _interopRequireDefault(require("../ValidationError"));
+
 var _pathToString = _interopRequireDefault(require("../util/pathToString"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function isNonNullable(t) {
   return t !== null || t !== undefined;
 }
+
 function convertToValidationMarker(validatorResult, level, context) {
   var _validatorResult$path;
+
   if (validatorResult === true) return [];
+
   if (Array.isArray(validatorResult)) {
     return validatorResult.flatMap(child => convertToValidationMarker(child, level, context)).filter(isNonNullable);
   }
+
   if (typeof validatorResult === 'string') {
     return convertToValidationMarker(new _ValidationError.default(validatorResult), level, context);
   }
+
   if (!(validatorResult instanceof _ValidationError.default)) {
     // in order to accept the `ValidationErrorLike`, it at least needs to have
     // a `message` in the object
     if (typeof (validatorResult === null || validatorResult === void 0 ? void 0 : validatorResult.message) !== 'string') {
       throw new Error("".concat((0, _pathToString.default)(context.path), ": Validator must return 'true' if valid or an error message as a string on errors"));
-    }
-
-    // this is the occurs when an object is returned that wasn't created with the
+    } // this is the occurs when an object is returned that wasn't created with the
     // `ValidationErrorClass`. in this case, we want to convert it to a class
+
+
     return convertToValidationMarker(new _ValidationError.default(validatorResult.message, validatorResult), level, context);
   }
-  var results = [];
 
-  // the validator result does not include any item-level relative paths,
+  var results = []; // the validator result does not include any item-level relative paths,
   // then just return the top-level path with the validation result
+
   if (!((_validatorResult$path = validatorResult.paths) !== null && _validatorResult$path !== void 0 && _validatorResult$path.length)) {
     return [{
       type: 'validation',
@@ -42,11 +51,11 @@ function convertToValidationMarker(validatorResult, level, context) {
       item: validatorResult,
       path: context.path || []
     }];
-  }
-
-  // if the validator result did include item-level relative paths, then for
+  } // if the validator result did include item-level relative paths, then for
   // each item-level relative path, create a validation marker that concatenates
   // the relative path with the path from the validation context
+
+
   return results.concat(validatorResult.paths.map(path => ({
     type: 'validation',
     path: (context.path || []).concat(path),

package/lib/util/deepEquals.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = deepEquals;
+
 /**
  * Modified version of fast-deep-equal (https://github.com/epoberezkin/fast-deep-equal)
  * MIT-licensed, copyright (c) 2017 Evgeny Poberezkin
  **/
-
 // NOTE: when converting to typescript, some of the checks were inlined (vs
 // having them in a variable) because the type predicate type narrowing only
 // works when type predicate is called inline in the condition that starts the
@@ -18,53 +18,70 @@ function deepEquals(a, b) {
   if (a === b) {
     return true;
   }
+
   if (Array.isArray(a) && Array.isArray(b)) {
     if (a.length != b.length) return false;
+
     for (var 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') {
     var 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 (var _i = 0; _i < keys.length; _i++) {
       if (keys[_i] === '_key') {
         continue;
       }
+
       if (!Object.prototype.hasOwnProperty.call(b, keys[_i])) {
         return false;
       }
     }
+
     for (var _i2 = 0; _i2 < keys.length; _i2++) {
       var key = keys[_i2];
+
       if (key === '_key') {
         continue;
       }
+
       if (!deepEquals(a[key], b[key])) {
         return false;
       }
     }
+
     return true;
   }
+
   return false;
 }

package/lib/util/escapeRegex.js

@@ -4,8 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-/* eslint-disable no-useless-escape */var _default = string => {
+
+/* eslint-disable no-useless-escape */
+var _default = string => {
   // Escape ^$.*+-?=!:|\/()[]{},
   return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&');
 };
+
 exports.default = _default;

package/lib/util/normalizeValidationRules.js

@@ -4,12 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = normalizeValidationRules;
+
 var _Rule = _interopRequireDefault(require("../Rule"));
+
 var _slugValidator = require("../validators/slugValidator");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 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; }
+
 var ruleConstraintTypes = {
   array: true,
   boolean: true,
@@ -18,7 +25,9 @@ var ruleConstraintTypes = {
   object: true,
   string: true
 };
+
 var isRuleConstraint = typeString => typeString in ruleConstraintTypes;
+
 function getTypeChain(type, visited) {
   if (!type) return [];
   if (visited.has(type)) return [];
@@ -26,23 +35,24 @@ function getTypeChain(type, visited) {
   var next = type.type ? getTypeChain(type.type, visited) : [];
   return [...next, type];
 }
+
 function baseRuleReducer(inputRule, type) {
   var baseRule = inputRule;
+
   if (isRuleConstraint(type.jsonType)) {
     baseRule = baseRule.type(type.jsonType);
   }
-  var typeOptionsList =
-  // if type.options is truthy
-  (type === null || type === void 0 ? void 0 : type.options) &&
-  // and type.options is an object (non-null from the previous)
-  typeof type.options === 'object' &&
-  // and if `list` is in options
-  'list' in type.options &&
-  // then finally access the list
+
+  var typeOptionsList = // if type.options is truthy
+  (type === null || type === void 0 ? void 0 : type.options) && // and type.options is an object (non-null from the previous)
+  typeof type.options === 'object' && // and if `list` is in options
+  'list' in type.options && // then finally access the list
   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();
@@ -51,6 +61,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);
@@ -58,6 +69,7 @@ function hasValueField(typeDef) {
   if (!Array.isArray(typeDef.fields)) return false;
   return typeDef.fields.some(field => field.name === 'value');
 }
+
 function extractValueFromListOption(option, typeDef) {
   // If you define a `list` option with object items, where the item has a `value` field,
   // we don't want to treat that as the value but rather the surrounding object
@@ -65,32 +77,38 @@ function extractValueFromListOption(option, typeDef) {
   if (typeDef.jsonType === 'object' && hasValueField(typeDef)) return option;
   return option.value === undefined ? option : option.value;
 }
-
 /**
  * Takes in `SchemaValidationValue` and returns an array of `Rule` instances.
  */
+
+
 function normalizeValidationRules(typeDef) {
   if (!typeDef) {
     return [];
   }
+
   var validation = typeDef.validation;
+
   if (Array.isArray(validation)) {
     return validation.flatMap(i => normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
       validation: i
     })));
   }
+
   if (validation instanceof _Rule.default) {
     return [validation];
   }
-  var baseRule =
-  // using an object + Object.values to de-dupe the type chain by type name
+
+  var baseRule = // using an object + Object.values to de-dupe the type chain by type name
   Object.values(getTypeChain(typeDef, new Set()).reduce((acc, type) => {
     acc[type.name] = type;
     return acc;
   }, {})).reduce(baseRuleReducer, new _Rule.default(typeDef));
+
   if (!validation) {
     return [baseRule];
   }
+
   return normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
     validation: validation(baseRule)
   }));

package/lib/util/pathToString.js

@@ -4,21 +4,27 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = pathToString;
+
 var _types = require("@sanity/types");
+
 function pathToString() {
   var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return path.reduce((target, segment, i) => {
     var segmentType = typeof segment;
+
     if (segmentType === 'number') {
       return "".concat(target, "[").concat(segment, "]");
     }
+
     if (segmentType === 'string') {
       var separator = i === 0 ? '' : '.';
       return "".concat(target).concat(separator).concat(segment);
     }
+
     if ((0, _types.isKeyedObject)(segment)) {
       return "".concat(target, "[_key==\"").concat(segment._key, "\"]");
     }
+
     throw new Error("Unsupported path segment \"".concat(segment, "\""));
   }, '');
 }

package/lib/util/requestIdleCallback.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.requestIdleCallback = exports.cancelIdleCallback = void 0;
+
 /**
  * Simple requestIdleCallback polyfill
  * Can be removed when all browsers support requestIdleCallback: https://caniuse.com/requestidlecallback
@@ -15,15 +16,19 @@ var requestIdleCallbackShim = function requestIdleCallbackShim(callback, options
   return window.setTimeout(() => {
     callback({
       didTimeout: false,
+
       timeRemaining() {
         return Math.max(0, Date.now() - start);
       }
+
     });
   }, 0);
 };
+
 var cancelIdleCallbackShim = function cancelIdleCallbackShim(handle) {
   return window.clearTimeout(handle);
 };
+
 var requestIdleCallback = window.requestIdleCallback || requestIdleCallbackShim;
 exports.requestIdleCallback = requestIdleCallback;
 var cancelIdleCallback = window.cancelIdleCallback || cancelIdleCallbackShim;

package/lib/util/typeString.js

@@ -8,18 +8,21 @@ exports.default = typeString;
 // https://github.com/stephenhandley/type-of-is/blob/7138a7e79f5af7c286bf8123f60843a91aaebf38/index.js
 var _toString = {}.toString;
 var builtIns = [Object, Function, Array, String, Boolean, Number, Date, RegExp, Error];
+
 function isBuiltIn(_constructor) {
   for (var i = 0; i < builtIns.length; i++) {
     if (builtIns[i] === _constructor) return true;
   }
+
   return false;
 }
+
 function typeString(obj) {
   // [object Blah] -> Blah
   var stringType = _toString.call(obj).slice(8, -1);
-  if (obj === null || obj === undefined) return stringType.toLowerCase();
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  if (obj === null || obj === undefined) return stringType.toLowerCase(); // eslint-disable-next-line @typescript-eslint/ban-types
+
   var constructorType = obj.constructor;
   if (constructorType && !isBuiltIn(constructorType)) return constructorType.name;
   return stringType;

package/lib/validateDocument.js

@@ -7,57 +7,92 @@ exports.default = validateDocument;
 exports.resolveTypeForArrayItem = resolveTypeForArrayItem;
 exports.validateDocumentObservable = validateDocumentObservable;
 exports.validateItem = validateItem;
+
 var _uniqBy2 = _interopRequireDefault(require("lodash/uniqBy"));
+
 var _flatten2 = _interopRequireDefault(require("lodash/flatten"));
+
 var _types = require("@sanity/types");
+
 var _rxjs = require("rxjs");
+
 var _operators = require("rxjs/operators");
+
 var _typeString = _interopRequireDefault(require("./util/typeString"));
+
 var _requestIdleCallback = require("./util/requestIdleCallback");
+
 var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
 var _normalizeValidationRules = _interopRequireDefault(require("./util/normalizeValidationRules"));
+
 var _excluded = ["value", "type", "path", "parent"];
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 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; }
+
 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; }
+
 var isRecord = maybeRecord => typeof maybeRecord === 'object' && maybeRecord !== null && !Array.isArray(maybeRecord);
-var isNonNullable = value => value !== null && value !== undefined;
 
+var isNonNullable = value => value !== null && value !== undefined;
 /**
  * @internal
  */
+
+
 function resolveTypeForArrayItem(item, candidates) {
   // if there is only one type available, assume that it's the correct one
   if (candidates.length === 1) return candidates[0];
+
   var itemType = (0, _types.isTypedObject)(item) && item._type;
+
   var primitive = item === undefined || item === null || !itemType && (0, _typeString.default)(item).toLowerCase();
+
   if (primitive && primitive !== 'object') {
     return candidates.find(candidate => candidate.jsonType === primitive);
   }
+
   return candidates.find(candidate => {
     var _candidate$type;
+
     return ((_candidate$type = candidate.type) === null || _candidate$type === void 0 ? void 0 : _candidate$type.name) === itemType;
   }) || candidates.find(candidate => candidate.name === itemType) || candidates.find(candidate => candidate.name === 'object' && primitive === 'object');
 }
+
 var EMPTY_MARKERS = [];
+
 function validateDocument(doc, schema, context) {
   return validateDocumentObservable(doc, schema, context).toPromise();
 }
+
 function validateDocumentObservable(doc, schema, context) {
   var documentType = schema.get(doc._type);
+
   if (!documentType) {
     console.warn('Schema type for object type "%s" not found, skipping validation', doc._type);
     return (0, _rxjs.of)(EMPTY_MARKERS);
   }
+
   return validateItemObservable({
     parent: undefined,
     value: doc,
@@ -75,7 +110,6 @@ function validateDocumentObservable(doc, schema, context) {
     }]);
   }));
 }
-
 /**
  * this is used make optional properties required by replacing optionals with
  * `T[P] | undefined`. this is used to prevent errors in `validateItem` where
@@ -84,46 +118,46 @@ function validateDocumentObservable(doc, schema, context) {
  * https://medium.com/terria/typescript-transforming-optional-properties-to-required-properties-that-may-be-undefined-7482cb4e1585
  */
 
+
 function validateItem(opts) {
   return validateItemObservable(opts).toPromise();
 }
+
 function validateItemObservable(_ref) {
   var value = _ref.value,
-    type = _ref.type,
-    _ref$path = _ref.path,
-    path = _ref$path === void 0 ? [] : _ref$path,
-    parent = _ref.parent,
-    restOfContext = _objectWithoutProperties(_ref, _excluded);
-  var rules = (0, _normalizeValidationRules.default)(type);
-  // run validation for the current value
+      type = _ref.type,
+      _ref$path = _ref.path,
+      path = _ref$path === void 0 ? [] : _ref$path,
+      parent = _ref.parent,
+      restOfContext = _objectWithoutProperties(_ref, _excluded);
+
+  var rules = (0, _normalizeValidationRules.default)(type); // run validation for the current value
+
   var selfChecks = rules.map(rule => (0, _rxjs.defer)(() => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
     parent,
     path,
     type
-  }))));
+  })))); // run validation for nested values (conditionally)
 
-  // run validation for nested values (conditionally)
   var fieldChecks = [];
   var selfIsRequired = rules.some(rule => rule.isRequired());
-  var shouldRunNestedObjectValidation =
-  // run nested validation for objects
-  (type === null || type === void 0 ? void 0 : type.jsonType) === 'object' && (
-  // if the value is truthy
-  !!value ||
-  // or
+  var shouldRunNestedObjectValidation = // run nested validation for objects
+  (type === null || type === void 0 ? void 0 : type.jsonType) === 'object' && ( // if the value is truthy
+  !!value || // or
   // (the value is null or undefined) and the top-level value is required
   (value === null || value === undefined) && selfIsRequired);
+
   if (shouldRunNestedObjectValidation) {
     var fieldTypes = type.fields.reduce((acc, field) => {
       acc[field.name] = field.type;
       return acc;
-    }, {});
+    }, {}); // Validation for rules set at the object level with `Rule.fields({/* ... */})`
 
-    // Validation for rules set at the object level with `Rule.fields({/* ... */})`
     fieldChecks = fieldChecks.concat(rules.map(rule => rule._fieldRules).filter(isNonNullable).flatMap(fieldResults => Object.entries(fieldResults)).flatMap(_ref2 => {
       var _ref3 = _slicedToArray(_ref2, 2),
-        name = _ref3[0],
-        validation = _ref3[1];
+          name = _ref3[0],
+          validation = _ref3[1];
+
       var fieldType = fieldTypes[name];
       return (0, _normalizeValidationRules.default)(_objectSpread(_objectSpread({}, fieldType), {}, {
         validation
@@ -135,22 +169,22 @@ function validateItemObservable(_ref) {
           type: fieldType
         })));
       });
-    }));
+    })); // Validation from each field's schema `validation: Rule => {/* ... */}` function
 
-    // Validation from each field's schema `validation: Rule => {/* ... */}` function
     fieldChecks = fieldChecks.concat(type.fields.map(field => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
       parent: value,
       value: isRecord(value) ? value[field.name] : undefined,
       path: path.concat(field.name),
       type: field.type
     }))));
-  }
-
-  // note: unlike objects, arrays should not run nested validation for undefined
+  } // note: unlike objects, arrays should not run nested validation for undefined
   // values because we won't have a valid path to put a marker (i.e. missing the
   // key or index in the path) and the downstream form builder won't have a
   // valid target component
+
+
   var shouldRunNestedValidationForArrays = (type === null || type === void 0 ? void 0 : type.jsonType) === 'array' && Array.isArray(value);
+
   if (shouldRunNestedValidationForArrays) {
     fieldChecks = fieldChecks.concat(value.map(item => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
       parent: value,
@@ -160,14 +194,16 @@ function validateItemObservable(_ref) {
       } : value.indexOf(item)),
       type: resolveTypeForArrayItem(item, type.of)
     }))));
-  }
-
-  // markDefs also do no run nested validation if the parent object is undefined
+  } // markDefs also do no run nested validation if the parent object is undefined
   // for a similar reason to arrays
+
+
   var shouldRunNestedValidationForMarkDefs = (0, _types.isBlock)(value) && value.markDefs.length && (0, _types.isBlockSchemaType)(type);
+
   if (shouldRunNestedValidationForMarkDefs) {
     var _type$fields = _slicedToArray(type.fields, 1),
-      spanChildrenField = _type$fields[0];
+        spanChildrenField = _type$fields[0];
+
     var spanType = spanChildrenField.type.of.find(_types.isSpanSchemaType);
     var annotations = ((spanType === null || spanType === void 0 ? void 0 : spanType.annotations) || []).reduce((acc, annotationType) => {
       acc.set(annotationType.name, annotationType);
@@ -182,15 +218,18 @@ function validateItemObservable(_ref) {
       type: annotations.get(markDef._type)
     }))));
   }
+
   return (0, _rxjs.defer)(() => (0, _rxjs.merge)([...selfChecks, ...fieldChecks])).pipe((0, _operators.mergeMap)(validateNode => (0, _rxjs.concat)(idle(), validateNode), 40), (0, _operators.mergeAll)(), (0, _operators.toArray)(), (0, _operators.map)(_flatten2.default), (0, _operators.map)(results => {
     // run `uniqBy` if `_fieldRules` are present because they can
     // cause repeat markers
     if (rules.some(rule => rule._fieldRules)) {
       return (0, _uniqBy2.default)(results, rule => JSON.stringify(rule));
     }
+
     return results;
   }));
 }
+
 function idle(timeout) {
   return new _rxjs.Observable(observer => {
     var handle = (0, _requestIdleCallback.requestIdleCallback)(() => {