@sanity/validation 2.33.4-performance-opts.16 → 2.33.4-shopify.8

package/dist/dts/index.d.ts

@@ -10,5 +10,4 @@ declare const _default: {
 };
 export default _default;
 export { RuleClass as Rule, validateDocument, inferFromSchema, inferFromSchemaType };
-export { validateDocumentObservable } from './validateDocument';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,QAAQ,CAAA;AAC9B,OAAO,gBAAgB,MAAM,oBAAoB,CAAA;AACjD,OAAO,eAAe,MAAM,mBAAmB,CAAA;AAC/C,OAAO,mBAAmB,MAAM,uBAAuB,CAAA;;;;;;;AAEvD,wBAAwF;AACxF,OAAO,EAAC,SAAS,IAAI,IAAI,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAC,CAAA;AAElF,OAAO,EAAC,0BAA0B,EAAC,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,QAAQ,CAAA;AAC9B,OAAO,gBAAgB,MAAM,oBAAoB,CAAA;AACjD,OAAO,eAAe,MAAM,mBAAmB,CAAA;AAC/C,OAAO,mBAAmB,MAAM,uBAAuB,CAAA;;;;;;;AAEvD,wBAAwF;AACxF,OAAO,EAAC,SAAS,IAAI,IAAI,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAC,CAAA"}

package/dist/dts/validateDocument.d.ts

@@ -1,11 +1,9 @@
 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 declare function validateDocumentObservable(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
@@ -19,6 +17,6 @@ declare type ExplicitUndefined<T> = {
 declare type ValidateItemOptions = {
     value: unknown;
 } & ExplicitUndefined<ValidationContext>;
-export declare function validateItem(opts: ValidateItemOptions): Promise<ValidationMarker[]>;
+export declare function validateItem({ value, type, path, parent, ...restOfContext }: ValidateItemOptions): Promise<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,EAML,cAAc,EACd,MAAM,EACN,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAuB,UAAU,EAAK,MAAM,MAAM,CAAA;AAczD;;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,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAE7B;AAED,wBAAgB,0BAA0B,CACxC,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,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAEnF"}
+{"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;AAExC,wBAAsB,YAAY,CAAC,EACjC,KAAK,EACL,IAAI,EACJ,IAAS,EACT,MAAM,EACN,GAAG,aAAa,EACjB,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA4HnD"}

package/lib/index.js

@@ -28,25 +28,15 @@ Object.defineProperty(exports, "validateDocument", {
     return _validateDocument.default;
   }
 });
-Object.defineProperty(exports, "validateDocumentObservable", {
-  enumerable: true,
-  get: function get() {
-    return _validateDocument.validateDocumentObservable;
-  }
-});
 
 var _Rule = _interopRequireDefault(require("./Rule"));
 
-var _validateDocument = _interopRequireWildcard(require("./validateDocument"));
+var _validateDocument = _interopRequireDefault(require("./validateDocument"));
 
 var _inferFromSchema = _interopRequireDefault(require("./inferFromSchema"));
 
 var _inferFromSchemaType = _interopRequireDefault(require("./inferFromSchemaType"));
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var _default = {

package/lib/validateDocument.js

@@ -5,23 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 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"));
@@ -52,6 +43,10 @@ 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;
@@ -79,36 +74,8 @@ function resolveTypeForArrayItem(item, candidates) {
   }) || 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,
-    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)
-    }]);
-  }));
+function validateDocument(_x, _x2, _x3) {
+  return _validateDocument.apply(this, arguments);
 }
 /**
  * this is used make optional properties required by replacing optionals with
@@ -119,124 +86,146 @@ function validateDocumentObservable(doc, schema, context) {
  */
 
 
-function validateItem(opts) {
-  return validateItemObservable(opts).toPromise();
-}
+function _validateDocument() {
+  _validateDocument = _asyncToGenerator(function* (doc, schema, context) {
+    var documentType = schema.get(doc._type);
 
-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
-
-  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
-        })));
+    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
       });
-    })); // 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
-  // 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,
-      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((acc, annotationType) => {
-      acc.set(annotationType.name, annotationType);
-      return acc;
-    }, new Map());
-    fieldChecks = fieldChecks.concat(value.markDefs.map(markDef => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
-      parent: value,
-      value: markDef,
-      path: path.concat(['markDefs', {
-        _key: markDef._key
-      }]),
-      type: annotations.get(markDef._type)
-    }))));
-  }
+    } 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);
+}
 
-  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
+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);
+
+    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)
+      }))));
+    }
+
+    var results = (yield Promise.all([...selfChecks, ...nestedChecks])).flat(); // 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)(() => {
-      observer.complete();
-    }, timeout ? {
-      timeout
-    } : undefined);
-    return () => (0, _requestIdleCallback.cancelIdleCallback)(handle);
   });
+  return _validateItem.apply(this, arguments);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/validation",
-  "version": "2.33.4-performance-opts.16+6acb5be7ec",
+  "version": "2.33.4-shopify.8+b3097f8c9",
   "description": "Validation and warning infrastructure for Sanity projects",
   "main": "./lib/index.js",
   "types": "./dist/dts",
@@ -33,13 +33,12 @@
   },
   "devDependencies": {
     "@sanity/client": "^3.3.3",
-    "@sanity/schema": "2.33.4-performance-opts.16+6acb5be7ec"
+    "@sanity/schema": "2.33.4-shopify.8+b3097f8c9"
   },
   "dependencies": {
-    "@sanity/types": "2.33.4-performance-opts.16+6acb5be7ec",
+    "@sanity/types": "2.33.4-shopify.8+b3097f8c9",
     "date-fns": "^2.16.1",
-    "lodash": "^4.17.15",
-    "rxjs": "^6.5.3"
+    "lodash": "^4.17.15"
   },
-  "gitHead": "6acb5be7ec060806773c41c9b015f318e2fbfbd9"
+  "gitHead": "b3097f8c9ec8d874b3fd86005a17b0cb5eaf136c"
 }

package/src/index.ts

@@ -5,5 +5,3 @@ import inferFromSchemaType from './inferFromSchemaType'
 
 export default {Rule: RuleClass, validateDocument, inferFromSchema, inferFromSchemaType}
 export {RuleClass as Rule, validateDocument, inferFromSchema, inferFromSchemaType}
-
-export {validateDocumentObservable} from './validateDocument'

package/src/validateDocument.test.ts

@@ -687,4 +687,81 @@ describe('validateItem', () => {
       },
     ])
   })
+
+  it('runs all nested validation checks concurrently', async () => {
+    type Resolver = (value: true) => void
+    const resolvers = new Set<Resolver>()
+    const customValidationFn = () => new Promise<true>((resolve) => resolvers.add(resolve))
+
+    const schema: Schema = createSchema({
+      types: [
+        {
+          name: 'root',
+          type: 'object',
+          fields: [
+            {
+              name: 'level1Object',
+              type: 'object',
+              validation: (rule: Rule) => [
+                rule.custom(customValidationFn),
+                rule.fields({
+                  level2String: (r) => r.custom(customValidationFn),
+                }),
+              ],
+              fields: [
+                {
+                  name: 'level2String',
+                  type: 'string',
+                  validation: (rule: Rule) => rule.custom(customValidationFn),
+                },
+              ],
+            },
+            {
+              name: 'level1Array',
+              type: 'array',
+              validation: (rule: Rule) => rule.custom(customValidationFn),
+              of: [
+                {
+                  type: 'object',
+                  fields: [
+                    {
+                      name: 'level2Number',
+                      type: 'number',
+                      validation: (rule: Rule) => rule.custom(customValidationFn),
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+          validation: (rule: Rule) => rule.custom(customValidationFn),
+        },
+      ],
+    })
+
+    const value = {
+      level1Object: {level3String: 'a string'},
+      level1Array: [{level2Number: 5}],
+    }
+
+    const resultPromise = validateItem({
+      value,
+      document: undefined,
+      parent: undefined,
+      path: undefined,
+      type: schema.get('root'),
+      getDocumentExists: undefined,
+    })
+
+    // after `validateItem(...)` has been initiated, all of the custom
+    // validation calls should have fired so the resolver size should equal the
+    // amount of total fields
+    expect(resolvers.size).toBe(6)
+
+    for (const resolver of resolvers) {
+      resolver(true)
+    }
+
+    await resultPromise
+  })
 })

package/src/validateDocument.ts

@@ -1,20 +1,17 @@
 import {
-  isBlock,
-  isBlockSchemaType,
-  isKeyedObject,
-  isSpanSchemaType,
-  isTypedObject,
   SanityDocument,
   Schema,
   SchemaType,
   ValidationContext,
   ValidationMarker,
+  isKeyedObject,
+  isTypedObject,
+  isBlock,
+  isBlockSchemaType,
+  isSpanSchemaType,
 } from '@sanity/types'
-import {concat, defer, merge, Observable, of} from 'rxjs'
-import {catchError, map, mergeAll, mergeMap, toArray} from 'rxjs/operators'
-import {flatten, uniqBy} from 'lodash'
+import {uniqBy} from 'lodash'
 import typeString from './util/typeString'
-import {requestIdleCallback, cancelIdleCallback} from './util/requestIdleCallback'
 import ValidationErrorClass from './ValidationError'
 import normalizeValidationRules from './util/normalizeValidationRules'
 
@@ -48,47 +45,38 @@ export function resolveTypeForArrayItem(
     candidates.find((candidate) => candidate.name === 'object' && primitive === 'object')
   )
 }
-const EMPTY_MARKERS: ValidationMarker[] = []
 
-export default function validateDocument(
+export default async function validateDocument(
   doc: SanityDocument,
   schema: Schema,
   context?: Pick<ValidationContext, 'getDocumentExists'>
 ): Promise<ValidationMarker[]> {
-  return validateDocumentObservable(doc, schema, context).toPromise()
-}
-
-export function validateDocumentObservable(
-  doc: SanityDocument,
-  schema: Schema,
-  context?: Pick<ValidationContext, 'getDocumentExists'>
-): 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 of(EMPTY_MARKERS)
+    return []
   }
 
-  return validateItemObservable({
-    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),
-        },
-      ])
+  try {
+    return await validateItem({
+      parent: undefined,
+      value: doc,
+      path: [],
+      document: doc,
+      type: documentType,
+      getDocumentExists: context?.getDocumentExists,
     })
-  )
+  } catch (err) {
+    console.error(err)
+    return [
+      {
+        type: 'validation',
+        level: 'error',
+        path: [],
+        item: new ValidationErrorClass(err?.message),
+      },
+    ]
+  }
 }
 
 /**
@@ -106,32 +94,27 @@ type ValidateItemOptions = {
   value: unknown
 } & ExplicitUndefined<ValidationContext>
 
-export function validateItem(opts: ValidateItemOptions): Promise<ValidationMarker[]> {
-  return validateItemObservable(opts).toPromise()
-}
-
-function validateItemObservable({
+export async function validateItem({
   value,
   type,
   path = [],
   parent,
   ...restOfContext
-}: ValidateItemOptions): Observable<ValidationMarker[]> {
+}: ValidateItemOptions): Promise<ValidationMarker[]> {
   const rules = normalizeValidationRules(type)
+
   // run validation for the current value
   const selfChecks = rules.map((rule) =>
-    defer(() =>
-      rule.validate(value, {
-        ...restOfContext,
-        parent,
-        path,
-        type,
-      })
-    )
+    rule.validate(value, {
+      ...restOfContext,
+      parent,
+      path,
+      type,
+    })
   )
 
   // run validation for nested values (conditionally)
-  let fieldChecks: Array<Observable<ValidationMarker[]>> = []
+  let nestedChecks: Array<Promise<ValidationMarker[]>> = []
 
   const selfIsRequired = rules.some((rule) => rule.isRequired())
   const shouldRunNestedObjectValidation =
@@ -149,7 +132,7 @@ function validateItemObservable({
     }, {})
 
     // Validation for rules set at the object level with `Rule.fields({/* ... */})`
-    fieldChecks = fieldChecks.concat(
+    nestedChecks = nestedChecks.concat(
       rules
         .map((rule) => rule._fieldRules)
         .filter(isNonNullable)
@@ -158,22 +141,20 @@ function validateItemObservable({
           const fieldType = fieldTypes[name]
           return normalizeValidationRules({...fieldType, validation}).map((subRule) => {
             const nestedValue = isRecord(value) ? value[name] : undefined
-            return defer(() =>
-              subRule.validate(nestedValue, {
-                ...restOfContext,
-                parent: value,
-                path: path.concat(name),
-                type: fieldType,
-              })
-            )
+            return subRule.validate(nestedValue, {
+              ...restOfContext,
+              parent: value,
+              path: path.concat(name),
+              type: fieldType,
+            })
           })
         })
     )
 
     // Validation from each field's schema `validation: Rule => {/* ... */}` function
-    fieldChecks = fieldChecks.concat(
+    nestedChecks = nestedChecks.concat(
       type.fields.map((field) =>
-        validateItemObservable({
+        validateItem({
           ...restOfContext,
           parent: value,
           value: isRecord(value) ? value[field.name] : undefined,
@@ -191,9 +172,9 @@ function validateItemObservable({
   const shouldRunNestedValidationForArrays = type?.jsonType === 'array' && Array.isArray(value)
 
   if (shouldRunNestedValidationForArrays) {
-    fieldChecks = fieldChecks.concat(
+    nestedChecks = nestedChecks.concat(
       value.map((item) =>
-        validateItemObservable({
+        validateItem({
           ...restOfContext,
           parent: value,
           value: item,
@@ -214,16 +195,16 @@ function validateItemObservable({
     const spanType = spanChildrenField.type.of.find(isSpanSchemaType)
 
     const annotations = (spanType?.annotations || []).reduce<Map<string, SchemaType>>(
-      (acc, annotationType) => {
-        acc.set(annotationType.name, annotationType)
-        return acc
+      (map, annotationType) => {
+        map.set(annotationType.name, annotationType)
+        return map
       },
       new Map()
     )
 
-    fieldChecks = fieldChecks.concat(
+    nestedChecks = nestedChecks.concat(
       value.markDefs.map((markDef) =>
-        validateItemObservable({
+        validateItem({
           ...restOfContext,
           parent: value,
           value: markDef,
@@ -234,31 +215,13 @@ function validateItemObservable({
     )
   }
 
-  return defer(() => merge([...selfChecks, ...fieldChecks])).pipe(
-    mergeMap((validateNode) => concat(idle(), validateNode), 40),
-    mergeAll(),
-    toArray(),
-    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
-    })
-  )
-}
+  const results = (await Promise.all([...selfChecks, ...nestedChecks])).flat()
 
-function idle(timeout?: number): Observable<never> {
-  return new Observable<never>((observer) => {
-    const handle = requestIdleCallback(
-      () => {
-        observer.complete()
-      },
-      timeout ? {timeout} : undefined
-    )
+  // 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 () => cancelIdleCallback(handle)
-  })
+  return results
 }

package/dist/dts/util/requestIdleCallback.d.ts

@@ -1,3 +0,0 @@
-export declare const requestIdleCallback: ((callback: IdleRequestCallback, options?: IdleRequestOptions | undefined) => number) & typeof globalThis.requestIdleCallback;
-export declare const cancelIdleCallback: ((handle: number) => void) & typeof globalThis.cancelIdleCallback;
-//# sourceMappingURL=requestIdleCallback.d.ts.map

package/dist/dts/util/requestIdleCallback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requestIdleCallback.d.ts","sourceRoot":"","sources":["../../../src/util/requestIdleCallback.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,mBAAmB,+HAAwD,CAAA;AACxF,eAAO,MAAM,kBAAkB,mEAAsD,CAAA"}

package/lib/util/requestIdleCallback.js

@@ -1,35 +0,0 @@
-"use strict";
-
-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
- * @param callback
- * @param options
- */
-var requestIdleCallbackShim = function requestIdleCallbackShim(callback, options) {
-  var start = Date.now();
-  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;
-exports.cancelIdleCallback = cancelIdleCallback;

package/src/util/requestIdleCallback.ts

@@ -1,29 +0,0 @@
-/**
- * Simple requestIdleCallback polyfill
- * Can be removed when all browsers support requestIdleCallback: https://caniuse.com/requestidlecallback
- * @param callback
- * @param options
- */
-const requestIdleCallbackShim: typeof window.requestIdleCallback = function requestIdleCallbackShim(
-  callback,
-  options?
-): number {
-  const start = Date.now()
-  return window.setTimeout(() => {
-    callback({
-      didTimeout: false,
-      timeRemaining() {
-        return Math.max(0, Date.now() - start)
-      },
-    })
-  }, 0)
-}
-
-const cancelIdleCallbackShim: typeof window.cancelIdleCallback = function cancelIdleCallbackShim(
-  handle: number
-): void {
-  return window.clearTimeout(handle)
-}
-
-export const requestIdleCallback = window.requestIdleCallback || requestIdleCallbackShim
-export const cancelIdleCallback = window.cancelIdleCallback || cancelIdleCallbackShim