@sanity/validation 2.33.3-performance-opts.4 → 2.33.3-performance-opts.9

package/dist/dts/validateDocument.d.ts

@@ -1,9 +1,10 @@
 import { SanityDocument, Schema, SchemaType, ValidationContext, ValidationMarker } from '@sanity/types';
+import { Observable } from 'rxjs';
 /**
  * @internal
  */
 export declare function resolveTypeForArrayItem(item: unknown, candidates: SchemaType[]): SchemaType | undefined;
-export default function validateDocument(doc: SanityDocument, schema: Schema, context?: Pick<ValidationContext, 'getDocumentExists'>): Promise<ValidationMarker[]>;
+export default function validateDocument(doc: SanityDocument, schema: Schema, context?: Pick<ValidationContext, 'getDocumentExists'>): Observable<ValidationMarker[]>;
 /**
  * this is used make optional properties required by replacing optionals with
  * `T[P] | undefined`. this is used to prevent errors in `validateItem` where
@@ -17,6 +18,6 @@ declare type ExplicitUndefined<T> = {
 declare type ValidateItemOptions = {
     value: unknown;
 } & ExplicitUndefined<ValidationContext>;
-export declare function validateItem({ value, type, path, parent, ...restOfContext }: ValidateItemOptions): Promise<ValidationMarker[]>;
+export declare function validateItem({ value, type, path, parent, ...restOfContext }: ValidateItemOptions): Observable<ValidationMarker[]>;
 export {};
 //# sourceMappingURL=validateDocument.d.ts.map

package/dist/dts/validateDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateDocument.d.ts","sourceRoot":"","sources":["../../src/validateDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,MAAM,EACN,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAMjB,MAAM,eAAe,CAAA;AAYtB;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,EAAE,GACvB,UAAU,GAAG,SAAS,CAiBxB;AAED,wBAA8B,gBAAgB,CAC5C,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,GACrD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA2B7B;AAED;;;;;;GAMG;AACH,aAAK,iBAAiB,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC5F,CAAA;AAED,aAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,OAAO,CAAA;CACf,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;AAIxC,wBAAsB,YAAY,CAAC,EACjC,KAAK,EACL,IAAI,EACJ,IAAS,EACT,MAAM,EACN,GAAG,aAAa,EACjB,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6HnD"}
+{"version":3,"file":"validateDocument.d.ts","sourceRoot":"","sources":["../../src/validateDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,cAAc,EACd,MAAM,EACN,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAuB,UAAU,EAAK,MAAM,MAAM,CAAA;AAuBzD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,EAAE,GACvB,UAAU,GAAG,SAAS,CAiBxB;AAGD,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACtC,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,GACrD,UAAU,CAAC,gBAAgB,EAAE,CAAC,CA2BhC;AAED;;;;;;GAMG;AACH,aAAK,iBAAiB,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC5F,CAAA;AAED,aAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,OAAO,CAAA;CACf,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;AAExC,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,IAAI,EACJ,IAAS,EACT,MAAM,EACN,GAAG,aAAa,EACjB,EAAE,mBAAmB,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC,CAsItD"}

package/lib/validateDocument.js

@@ -9,8 +9,14 @@ 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 _ValidationError = _interopRequireDefault(require("./ValidationError"));
@@ -43,10 +49,6 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 
 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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
 var isRecord = maybeRecord => typeof maybeRecord === 'object' && maybeRecord !== null && !Array.isArray(maybeRecord);
 
 var isNonNullable = value => value !== null && value !== undefined;
@@ -74,8 +76,32 @@ function resolveTypeForArrayItem(item, candidates) {
   }) || candidates.find(candidate => candidate.name === itemType) || candidates.find(candidate => candidate.name === 'object' && primitive === 'object');
 }
 
-function validateDocument(_x, _x2, _x3) {
-  return _validateDocument.apply(this, arguments);
+var EMPTY_MARKERS = [];
+
+function validateDocument(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 validateItem({
+    parent: undefined,
+    value: doc,
+    path: [],
+    document: doc,
+    type: documentType,
+    getDocumentExists: context === null || context === void 0 ? void 0 : context.getDocumentExists
+  }).pipe((0, _operators.catchError)(err => {
+    console.error(err);
+    return (0, _rxjs.of)([{
+      type: 'validation',
+      level: 'error',
+      path: [],
+      item: new _ValidationError.default(err === null || err === void 0 ? void 0 : err.message)
+    }]);
+  }));
 }
 /**
  * this is used make optional properties required by replacing optionals with
@@ -86,149 +112,120 @@ function validateDocument(_x, _x2, _x3) {
  */
 
 
-function _validateDocument() {
-  _validateDocument = _asyncToGenerator(function* (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 [];
-    }
-
-    try {
-      return yield validateItem({
-        parent: undefined,
-        value: doc,
-        path: [],
-        document: doc,
-        type: documentType,
-        getDocumentExists: context === null || context === void 0 ? void 0 : context.getDocumentExists
+function validateItem(_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
+
+  var selfChecks = rules.map(rule => (0, _rxjs.defer)(() => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
+    parent,
+    path,
+    type
+  })))); // 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
+  // (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({/* ... */})`
+
+    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];
+
+      var fieldType = fieldTypes[name];
+      return (0, _normalizeValidationRules.default)(_objectSpread(_objectSpread({}, fieldType), {}, {
+        validation
+      })).map(subRule => {
+        var nestedValue = isRecord(value) ? value[name] : undefined;
+        return (0, _rxjs.defer)(() => subRule.validate(nestedValue, _objectSpread(_objectSpread({}, restOfContext), {}, {
+          parent: value,
+          path: path.concat(name),
+          type: fieldType
+        })));
       });
-    } catch (err) {
-      console.error(err);
-      return [{
-        type: 'validation',
-        level: 'error',
-        path: [],
-        item: new _ValidationError.default(err === null || err === void 0 ? void 0 : err.message)
-      }];
-    }
-  });
-  return _validateDocument.apply(this, arguments);
-}
-
-var idle = () => new Promise(resolve => window.requestIdleCallback(resolve));
-
-function validateItem(_x4) {
-  return _validateItem.apply(this, arguments);
-}
-
-function _validateItem() {
-  _validateItem = _asyncToGenerator(function* (_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);
-
-    yield idle();
-    var rules = (0, _normalizeValidationRules.default)(type); // run validation for the current value
-
-    var selfChecks = rules.map(rule => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
-      parent,
-      path,
-      type
-    }))); // run validation for nested values (conditionally)
-
-    var nestedChecks = [];
-    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
-    // (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({/* ... */})`
-
-      nestedChecks = nestedChecks.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];
-
-        var fieldType = fieldTypes[name];
-        return (0, _normalizeValidationRules.default)(_objectSpread(_objectSpread({}, fieldType), {}, {
-          validation
-        })).map(subRule => {
-          var nestedValue = isRecord(value) ? value[name] : undefined;
-          return subRule.validate(nestedValue, _objectSpread(_objectSpread({}, restOfContext), {}, {
-            parent: value,
-            path: path.concat(name),
-            type: fieldType
-          }));
-        });
-      })); // Validation from each field's schema `validation: Rule => {/* ... */}` function
-
-      nestedChecks = nestedChecks.concat(type.fields.map(field => validateItem(_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
-    // 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) {
-      nestedChecks = nestedChecks.concat(value.map(item => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
-        parent: value,
-        value: item,
-        path: path.concat((0, _types.isKeyedObject)(item) ? {
-          _key: item._key
-        } : value.indexOf(item)),
-        type: resolveTypeForArrayItem(item, type.of)
-      }))));
-    } // 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];
-
-      var spanType = spanChildrenField.type.of.find(_types.isSpanSchemaType);
-      var annotations = ((spanType === null || spanType === void 0 ? void 0 : spanType.annotations) || []).reduce((map, annotationType) => {
-        map.set(annotationType.name, annotationType);
-        return map;
-      }, 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)
-      }))));
-    }
+    })); // Validation from each field's schema `validation: Rule => {/* ... */}` function
+
+    fieldChecks = fieldChecks.concat(type.fields.map(field => validateItem(_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
+  // 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 => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
+      parent: value,
+      value: item,
+      path: path.concat((0, _types.isKeyedObject)(item) ? {
+        _key: item._key
+      } : value.indexOf(item)),
+      type: resolveTypeForArrayItem(item, type.of)
+    }))));
+  } // 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];
+
+    var spanType = spanChildrenField.type.of.find(_types.isSpanSchemaType);
+    var annotations = ((spanType === null || spanType === void 0 ? void 0 : spanType.annotations) || []).reduce((map, annotationType) => {
+      map.set(annotationType.name, annotationType);
+      return map;
+    }, new Map());
+    fieldChecks = fieldChecks.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)
+    }))));
+  }
 
-    var results = (yield Promise.all([...selfChecks, ...nestedChecks])).flat(); // run `uniqBy` if `_fieldRules` are present because they can
+  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.filter)(arr => arr.length > 0), (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;
+  }), (0, _operators.filter)(arr => arr.length > 0));
+}
+
+function idle(timeout) {
+  return new _rxjs.Observable(observer => {
+    var handle = requestIdleCallback(() => {
+      observer.complete();
+    }, timeout ? {
+      timeout
+    } : undefined);
+    return () => cancelIdleCallback(handle);
   });
-  return _validateItem.apply(this, arguments);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/validation",
-  "version": "2.33.3-performance-opts.4+87ec2ee6e8",
+  "version": "2.33.3-performance-opts.9+6ea72536ea",
   "description": "Validation and warning infrastructure for Sanity projects",
   "main": "./lib/index.js",
   "types": "./dist/dts",
@@ -33,12 +33,13 @@
   },
   "devDependencies": {
     "@sanity/client": "^3.3.3",
-    "@sanity/schema": "2.33.3-performance-opts.4+87ec2ee6e8"
+    "@sanity/schema": "2.33.3-performance-opts.9+6ea72536ea"
   },
   "dependencies": {
-    "@sanity/types": "2.33.3-performance-opts.4+87ec2ee6e8",
+    "@sanity/types": "2.33.3-performance-opts.9+6ea72536ea",
     "date-fns": "^2.16.1",
-    "lodash": "^4.17.15"
+    "lodash": "^4.17.15",
+    "rxjs": "^6.5.3"
   },
-  "gitHead": "87ec2ee6e85a8cb44368bde6557516e9ed024af0"
+  "gitHead": "6ea72536ea8c9aaebb1c57b304fc23f1e6705a67"
 }

package/src/validateDocument.ts

@@ -1,16 +1,28 @@
 import {
+  isBlock,
+  isBlockSchemaType,
+  isKeyedObject,
+  isSpanSchemaType,
+  isTypedObject,
   SanityDocument,
   Schema,
   SchemaType,
   ValidationContext,
   ValidationMarker,
-  isKeyedObject,
-  isTypedObject,
-  isBlock,
-  isBlockSchemaType,
-  isSpanSchemaType,
 } from '@sanity/types'
-import {uniqBy} from 'lodash'
+import {concat, defer, merge, Observable, of} from 'rxjs'
+import {
+  catchError,
+  combineAll,
+  concatMap,
+  filter,
+  map,
+  mergeAll,
+  mergeMap,
+  tap,
+  toArray,
+} from 'rxjs/operators'
+import {flatten, uniqBy} from 'lodash'
 import typeString from './util/typeString'
 import ValidationErrorClass from './ValidationError'
 import normalizeValidationRules from './util/normalizeValidationRules'
@@ -45,38 +57,39 @@ export function resolveTypeForArrayItem(
     candidates.find((candidate) => candidate.name === 'object' && primitive === 'object')
   )
 }
+const EMPTY_MARKERS: ValidationMarker[] = []
 
-export default async function validateDocument(
+export default function validateDocument(
   doc: SanityDocument,
   schema: Schema,
   context?: Pick<ValidationContext, 'getDocumentExists'>
-): Promise<ValidationMarker[]> {
+): Observable<ValidationMarker[]> {
   const documentType = schema.get(doc._type)
   if (!documentType) {
     console.warn('Schema type for object type "%s" not found, skipping validation', doc._type)
-    return []
+    return of(EMPTY_MARKERS)
   }
 
-  try {
-    return await validateItem({
-      parent: undefined,
-      value: doc,
-      path: [],
-      document: doc,
-      type: documentType,
-      getDocumentExists: context?.getDocumentExists,
+  return validateItem({
+    parent: undefined,
+    value: doc,
+    path: [],
+    document: doc,
+    type: documentType,
+    getDocumentExists: context?.getDocumentExists,
+  }).pipe(
+    catchError((err) => {
+      console.error(err)
+      return of([
+        {
+          type: 'validation' as const,
+          level: 'error' as const,
+          path: [],
+          item: new ValidationErrorClass(err?.message),
+        },
+      ])
     })
-  } catch (err) {
-    console.error(err)
-    return [
-      {
-        type: 'validation',
-        level: 'error',
-        path: [],
-        item: new ValidationErrorClass(err?.message),
-      },
-    ]
-  }
+  )
 }
 
 /**
@@ -94,30 +107,28 @@ type ValidateItemOptions = {
   value: unknown
 } & ExplicitUndefined<ValidationContext>
 
-const idle = () => new Promise((resolve) => window.requestIdleCallback(resolve))
-
-export async function validateItem({
+export function validateItem({
   value,
   type,
   path = [],
   parent,
   ...restOfContext
-}: ValidateItemOptions): Promise<ValidationMarker[]> {
-  await idle()
+}: ValidateItemOptions): Observable<ValidationMarker[]> {
   const rules = normalizeValidationRules(type)
-
   // run validation for the current value
   const selfChecks = rules.map((rule) =>
-    rule.validate(value, {
-      ...restOfContext,
-      parent,
-      path,
-      type,
-    })
+    defer(() =>
+      rule.validate(value, {
+        ...restOfContext,
+        parent,
+        path,
+        type,
+      })
+    )
   )
 
   // run validation for nested values (conditionally)
-  let nestedChecks: Array<Promise<ValidationMarker[]>> = []
+  let fieldChecks: Array<Observable<ValidationMarker[]>> = []
 
   const selfIsRequired = rules.some((rule) => rule.isRequired())
   const shouldRunNestedObjectValidation =
@@ -135,7 +146,7 @@ export async function validateItem({
     }, {})
 
     // Validation for rules set at the object level with `Rule.fields({/* ... */})`
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       rules
         .map((rule) => rule._fieldRules)
         .filter(isNonNullable)
@@ -144,18 +155,20 @@ export async function validateItem({
           const fieldType = fieldTypes[name]
           return normalizeValidationRules({...fieldType, validation}).map((subRule) => {
             const nestedValue = isRecord(value) ? value[name] : undefined
-            return subRule.validate(nestedValue, {
-              ...restOfContext,
-              parent: value,
-              path: path.concat(name),
-              type: fieldType,
-            })
+            return defer(() =>
+              subRule.validate(nestedValue, {
+                ...restOfContext,
+                parent: value,
+                path: path.concat(name),
+                type: fieldType,
+              })
+            )
           })
         })
     )
 
     // Validation from each field's schema `validation: Rule => {/* ... */}` function
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       type.fields.map((field) =>
         validateItem({
           ...restOfContext,
@@ -175,7 +188,7 @@ export async function validateItem({
   const shouldRunNestedValidationForArrays = type?.jsonType === 'array' && Array.isArray(value)
 
   if (shouldRunNestedValidationForArrays) {
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       value.map((item) =>
         validateItem({
           ...restOfContext,
@@ -205,7 +218,7 @@ export async function validateItem({
       new Map()
     )
 
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       value.markDefs.map((markDef) =>
         validateItem({
           ...restOfContext,
@@ -218,13 +231,33 @@ export async function validateItem({
     )
   }
 
-  const results = (await Promise.all([...selfChecks, ...nestedChecks])).flat()
+  return defer(() => merge([...selfChecks, ...fieldChecks])).pipe(
+    mergeMap((validateNode) => concat(idle(), validateNode), 40),
+    mergeAll(),
+    toArray(),
+    filter((arr) => arr.length > 0),
+    map(flatten),
+    map((results) => {
+      // run `uniqBy` if `_fieldRules` are present because they can
+      // cause repeat markers
+      if (rules.some((rule) => rule._fieldRules)) {
+        return uniqBy(results, (rule) => JSON.stringify(rule))
+      }
+      return results
+    }),
+    filter((arr) => arr.length > 0)
+  )
+}
 
-  // run `uniqBy` if `_fieldRules` are present because they can
-  // cause repeat markers
-  if (rules.some((rule) => rule._fieldRules)) {
-    return uniqBy(results, (rule) => JSON.stringify(rule))
-  }
+function idle(timeout?: number): Observable<never> {
+  return new Observable<never>((observer) => {
+    const handle = requestIdleCallback(
+      () => {
+        observer.complete()
+      },
+      timeout ? {timeout} : undefined
+    )
 
-  return results
+    return () => cancelIdleCallback(handle)
+  })
 }