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

package/lib/Rule.js

@@ -4,24 +4,43 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _get2 = _interopRequireDefault(require("lodash/get"));
+
 var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
+
 var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
 var _escapeRegex = _interopRequireDefault(require("./util/escapeRegex"));
+
 var _convertToValidationMarker = _interopRequireDefault(require("./util/convertToValidationMarker"));
+
 var _pathToString = _interopRequireDefault(require("./util/pathToString"));
+
 var _genericValidator = _interopRequireDefault(require("./validators/genericValidator"));
+
 var _booleanValidator = _interopRequireDefault(require("./validators/booleanValidator"));
+
 var _numberValidator = _interopRequireDefault(require("./validators/numberValidator"));
+
 var _stringValidator = _interopRequireDefault(require("./validators/stringValidator"));
+
 var _arrayValidator = _interopRequireDefault(require("./validators/arrayValidator"));
+
 var _objectValidator = _interopRequireDefault(require("./validators/objectValidator"));
+
 var _dateValidator = _interopRequireDefault(require("./validators/dateValidator"));
+
 var _class;
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 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); }); }; }
+
 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 typeValidators = {
   Boolean: _booleanValidator.default,
   Number: _numberValidator.default,
@@ -30,18 +49,19 @@ var typeValidators = {
   Object: _objectValidator.default,
   Date: _dateValidator.default
 };
+
 var getBaseType = type => {
   return type && type.type ? getBaseType(type.type) : type;
 };
+
 var isFieldRef = constraint => {
   if (typeof constraint !== 'object' || !constraint) return false;
   return constraint.type === Rule.FIELD_REF;
 };
+
 var EMPTY_ARRAY = [];
 var FIELD_REF = Symbol('FIELD_REF');
-var ruleConstraintTypes = ['Array', 'Boolean', 'Date', 'Number', 'Object', 'String'];
-
-// Note: `RuleClass` and `Rule` are split to fit the current `@sanity/types`
+var ruleConstraintTypes = ['Array', 'Boolean', 'Date', 'Number', 'Object', 'String']; // Note: `RuleClass` and `Rule` are split to fit the current `@sanity/types`
 // setup. Classes are a bit weird in the `@sanity/types` package because classes
 // create an actual javascript class while simultaneously creating a type
 // definition.
@@ -56,26 +76,35 @@ var ruleConstraintTypes = ['Array', 'Boolean', 'Date', 'Number', 'Object', 'Stri
 // This package exports the RuleClass as a value without implicitly exporting
 // an instance definition. This should help reminder downstream users to import
 // from the `@sanity/types` package.
+
 var Rule = (_class = class Rule {
   constructor(typeDef) {
     _defineProperty(this, "_type", undefined);
+
     _defineProperty(this, "_level", undefined);
+
     _defineProperty(this, "_required", undefined);
+
     _defineProperty(this, "_typeDef", undefined);
+
     _defineProperty(this, "_message", undefined);
+
     _defineProperty(this, "_rules", []);
+
     _defineProperty(this, "_fieldRules", undefined);
+
     _defineProperty(this, "valueOfField", Rule.valueOfField.bind(Rule));
+
     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 undefined;
-  }
+  } // Alias to static method, since we often have access to an _instance_ of a rule but not the actual Rule class
 
-  // Alias to static method, since we often have access to an _instance_ of a rule but not the actual Rule class
 
   error(message) {
     var rule = this.clone();
@@ -83,18 +112,21 @@ var Rule = (_class = class Rule {
     rule._message = message || undefined;
     return rule;
   }
+
   warning(message) {
     var rule = this.clone();
     rule._level = 'warning';
     rule._message = message || undefined;
     return rule;
   }
+
   info(message) {
     var rule = this.clone();
     rule._level = 'info';
     rule._message = message || undefined;
     return rule;
   }
+
   reset() {
     this._type = this._type || undefined;
     this._rules = (this._rules || []).filter(rule => rule.flag === 'type');
@@ -104,9 +136,11 @@ var Rule = (_class = class Rule {
     this._fieldRules = undefined;
     return this;
   }
+
   isRequired() {
     return this._required === 'required';
   }
+
   clone() {
     var rule = new Rule();
     rule._type = this._type;
@@ -118,6 +152,7 @@ var Rule = (_class = class Rule {
     rule._typeDef = this._typeDef;
     return rule;
   }
+
   cloneWithRules(rules) {
     var rule = this.clone();
     var newRules = new Set();
@@ -125,6 +160,7 @@ var Rule = (_class = class Rule {
       if (curr.flag === 'type') {
         rule._type = curr.constraint;
       }
+
       newRules.add(curr.flag);
     });
     rule._rules = rule._rules.filter(curr => {
@@ -134,24 +170,28 @@ var Rule = (_class = class Rule {
     }).concat(rules);
     return rule;
   }
+
   merge(rule) {
     if (this._type && rule._type && this._type !== rule._type) {
       throw new Error('merge() failed: conflicting types');
     }
+
     var newRule = this.cloneWithRules(rule._rules);
     newRule._type = this._type || rule._type;
     newRule._message = this._message || rule._message;
     newRule._required = this._mergeRequired(rule);
     newRule._level = this._level === 'error' ? rule._level : this._level;
     return newRule;
-  }
+  } // Validation flag setters
+
 
-  // Validation flag setters
   type(targetType) {
     var type = "".concat(targetType.slice(0, 1).toUpperCase()).concat(targetType.slice(1));
+
     if (!ruleConstraintTypes.includes(type)) {
       throw new Error("Unknown type \"".concat(targetType, "\""));
     }
+
     var rule = this.cloneWithRules([{
       flag: 'type',
       constraint: type
@@ -159,20 +199,22 @@ var Rule = (_class = class Rule {
     rule._type = type;
     return rule;
   }
+
   all(children) {
     return this.cloneWithRules([{
       flag: 'all',
       constraint: children
     }]);
   }
+
   either(children) {
     return this.cloneWithRules([{
       flag: 'either',
       constraint: children
     }]);
-  }
+  } // Shared rules
+
 
-  // Shared rules
   optional() {
     var rule = this.cloneWithRules([{
       flag: 'presence',
@@ -181,6 +223,7 @@ var Rule = (_class = class Rule {
     rule._required = 'optional';
     return rule;
   }
+
   required() {
     var rule = this.cloneWithRules([{
       flag: 'presence',
@@ -189,100 +232,114 @@ var Rule = (_class = class Rule {
     rule._required = 'required';
     return rule;
   }
+
   custom(fn) {
     return this.cloneWithRules([{
       flag: 'custom',
       constraint: fn
     }]);
   }
-
   /**
    * @deprecated use `Rule.custom` instead
    */
+
+
   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) {
     var values = Array.isArray(value) ? value : [value];
     return this.cloneWithRules([{
       flag: 'valid',
       constraint: values
     }]);
-  }
+  } // Numbers only
+
 
-  // Numbers only
   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
     }]);
-  }
+  } // String only
+
 
-  // String only
   uppercase() {
     return this.cloneWithRules([{
       flag: 'stringCasing',
       constraint: 'uppercase'
     }]);
   }
+
   lowercase() {
     return this.cloneWithRules([{
       flag: 'stringCasing',
       constraint: 'lowercase'
     }]);
   }
+
   regex(pattern, a, b) {
     var _a$name, _a$invert;
+
     var name = typeof a === 'string' ? a : (_a$name = a === null || a === void 0 ? void 0 : a.name) !== null && _a$name !== void 0 ? _a$name : b === null || b === void 0 ? void 0 : b.name;
     var invert = typeof a === 'string' ? false : (_a$invert = a === null || a === void 0 ? void 0 : a.invert) !== null && _a$invert !== void 0 ? _a$invert : b === null || b === void 0 ? void 0 : b.invert;
     var constraint = {
@@ -295,23 +352,28 @@ var Rule = (_class = class Rule {
       constraint
     }]);
   }
+
   email() {
     return this.cloneWithRules([{
       flag: 'email'
     }]);
   }
+
   uri(opts) {
     var optsScheme = (opts === null || opts === void 0 ? void 0 : opts.scheme) || ['http', 'https'];
     var schemes = Array.isArray(optsScheme) ? optsScheme : [optsScheme];
+
     if (!schemes.length) {
       throw new Error('scheme must have at least 1 scheme specified');
     }
+
     var 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((0, _escapeRegex.default)(scheme), "$")) : scheme;
         }),
         allowRelative: (opts === null || opts === void 0 ? void 0 : opts.allowRelative) || false,
@@ -323,37 +385,42 @@ var Rule = (_class = class Rule {
       flag: 'uri',
       constraint
     }]);
-  }
+  } // Array only
+
 
-  // Array only
   unique() {
     return this.cloneWithRules([{
       flag: 'unique'
     }]);
-  }
+  } // Objects only
+
 
-  // Objects only
   reference() {
     return this.cloneWithRules([{
       flag: 'reference'
     }]);
   }
+
   fields(rules) {
     if (this._type !== 'Object') {
       throw new Error('fields() can only be called on an object type');
     }
+
     var rule = this.cloneWithRules([]);
     rule._fieldRules = rules;
     return rule;
   }
+
   assetRequired() {
     var base = getBaseType(this._typeDef);
     var assetType;
+
     if (base && ['image', 'file'].includes(base.name)) {
       assetType = base.name === 'image' ? 'Image' : 'File';
     } else {
       assetType = 'Asset';
     }
+
     return this.cloneWithRules([{
       flag: 'assetRequired',
       constraint: {
@@ -361,19 +428,20 @@ var Rule = (_class = class Rule {
       }
     }]);
   }
+
   validate(value) {
     var _arguments = arguments,
-      _this = this;
+        _this = this;
+
     return _asyncToGenerator(function* () {
       var context = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
-      var valueIsEmpty = value === null || value === undefined;
+      var valueIsEmpty = value === null || value === undefined; // Short-circuit on optional, empty fields
 
-      // Short-circuit on optional, empty fields
       if (valueIsEmpty && _this._required === 'optional') {
         return EMPTY_ARRAY;
       }
-      var rules =
-      // Run only the _custom_ functions if the rule is not set to required or optional
+
+      var rules = // Run only the _custom_ functions if the rule is not set to required or optional
       _this._required === undefined && valueIsEmpty ? _this._rules.filter(curr => curr.flag === 'custom') : _this._rules;
       var validators = _this._type && typeValidators[_this._type] || _genericValidator.default;
       var results = yield Promise.all(rules.map( /*#__PURE__*/function () {
@@ -381,24 +449,32 @@ var Rule = (_class = class Rule {
           if (curr.flag === undefined) {
             throw new Error('Invalid rule, did not contain "flag"-property');
           }
+
           var validator = validators[curr.flag];
+
           if (!validator) {
             var 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));
           }
+
           var specConstraint = 'constraint' in curr ? curr.constraint : null;
+
           if (isFieldRef(specConstraint)) {
             specConstraint = (0, _get2.default)(context.parent, specConstraint.path);
           }
+
           var result;
+
           try {
             result = yield validator(specConstraint, value, _this._message, context);
           } catch (err) {
             var errorFromException = new _ValidationError.default("".concat((0, _pathToString.default)(context.path), ": Exception occurred while validating value: ").concat(err.message));
             return (0, _convertToValidationMarker.default)(errorFromException, 'error', context);
           }
+
           return (0, _convertToValidationMarker.default)(result, _this._level, context);
         });
+
         return function (_x) {
           return _ref.apply(this, arguments);
         };
@@ -406,6 +482,7 @@ var Rule = (_class = class Rule {
       return results.flat();
     })();
   }
+
 }, _defineProperty(_class, "FIELD_REF", FIELD_REF), _defineProperty(_class, "array", def => new _class(def).type('Array')), _defineProperty(_class, "object", def => new _class(def).type('Object')), _defineProperty(_class, "string", def => new _class(def).type('String')), _defineProperty(_class, "number", def => new _class(def).type('Number')), _defineProperty(_class, "boolean", def => new _class(def).type('Boolean')), _defineProperty(_class, "dateTime", def => new _class(def).type('Date')), _defineProperty(_class, "valueOfField", path => ({
   type: FIELD_REF,
   path

package/lib/ValidationError.js

@@ -4,20 +4,28 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 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; }
+
 // Follows the same pattern as Rule and RuleClass. @see Rule
 var ValidationError = class ValidationError {
   constructor(message) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
     _defineProperty(this, "message", void 0);
+
     _defineProperty(this, "paths", void 0);
+
     _defineProperty(this, "children", void 0);
+
     _defineProperty(this, "operation", void 0);
+
     this.message = message;
     this.paths = options.paths || [];
     this.children = options.children;
     this.operation = options.operation;
   }
+
   cloneWithMessage(msg) {
     return new ValidationError(msg, {
       paths: this.paths,
@@ -25,6 +33,7 @@ var ValidationError = class ValidationError {
       operation: this.operation
     });
   }
+
 };
 var _default = ValidationError;
 exports.default = _default;

package/lib/getClient.js

@@ -5,13 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = getClient;
 var client;
+
 function getClient() {
   if (!client) {
     // Lazy-loading to not cause issues when loading schema in node environment
     var sanityClient = require('part:@sanity/base/client');
+
     client = sanityClient.withConfig({
       apiVersion: '1'
     });
   }
+
   return client;
 }

package/lib/index.js

@@ -34,13 +34,21 @@ Object.defineProperty(exports, "validateDocumentObservable", {
     return _validateDocument.validateDocumentObservable;
   }
 });
+
 var _Rule = _interopRequireDefault(require("./Rule"));
+
 var _validateDocument = _interopRequireWildcard(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 = {
   Rule: _Rule.default,
   validateDocument: _validateDocument.default,

package/lib/inferFromSchema.js

@@ -4,8 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _inferFromSchemaType = _interopRequireDefault(require("./inferFromSchemaType"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 // Note: Mutates schema. Refactor when @sanity/schema supports middlewares
 function inferFromSchema(schema) {
   var typeNames = schema.getTypeNames();
@@ -14,5 +17,6 @@ function inferFromSchema(schema) {
   });
   return schema;
 }
+
 var _default = inferFromSchema;
 exports.default = _default;

package/lib/inferFromSchemaType.js

@@ -4,20 +4,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _normalizeValidationRules = _interopRequireDefault(require("./util/normalizeValidationRules"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
 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 traverse(typeDef, visited) {
   if (visited.has(typeDef)) {
     return;
   }
+
   visited.add(typeDef);
   typeDef.validation = (0, _normalizeValidationRules.default)(typeDef);
+
   if ('fields' in typeDef) {
     var _iterator = _createForOfIteratorHelper(typeDef.fields),
-      _step;
+        _step;
+
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var field = _step.value;
@@ -29,9 +38,11 @@ function traverse(typeDef, visited) {
       _iterator.f();
     }
   }
+
   if ('of' in typeDef) {
     var _iterator2 = _createForOfIteratorHelper(typeDef.of),
-      _step2;
+        _step2;
+
     try {
       for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
         var candidate = _step2.value;
@@ -42,15 +53,16 @@ function traverse(typeDef, visited) {
     } finally {
       _iterator2.f();
     }
-  }
-
-  // eslint-disable-next-line no-warning-comments
+  } // eslint-disable-next-line no-warning-comments
   // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet
+
+
   if (typeDef.annotations) {
     // eslint-disable-next-line no-warning-comments
     // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet
     var _iterator3 = _createForOfIteratorHelper(typeDef.annotations),
-      _step3;
+        _step3;
+
     try {
       for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var annotation = _step3.value;
@@ -62,13 +74,13 @@ function traverse(typeDef, visited) {
       _iterator3.f();
     }
   }
-}
+} // NOTE: this overload is for TS API compatibility with a previous implementation
 
-// NOTE: this overload is for TS API compatibility with a previous implementation
 
 function inferFromSchemaType(typeDef) {
   traverse(typeDef, new Set());
   return typeDef;
 }
+
 var _default = inferFromSchemaType;
 exports.default = _default;