@sanity/validation 3.1.4 → 3.1.5-canary.14

package/lib/index.cjs.mjs

@@ -0,0 +1,7 @@
+import cjs from './index.js';
+
+export const Rule = cjs.Rule;
+export const inferFromSchema = cjs.inferFromSchema;
+export const inferFromSchemaType = cjs.inferFromSchemaType;
+export const validateDocument = cjs.validateDocument;
+export const validateDocumentObservable = cjs.validateDocumentObservable;

package/lib/index.esm.js

@@ -1,9 +1,3 @@
-const _excluded = ["value", "type", "path", "parent"];
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 import cloneDeep from 'lodash/cloneDeep.js';
 import get from 'lodash/get.js';
 import { isKeyedObject, isReference, isPortableTextTextBlock, isBlockSchemaType, isSpanSchemaType, isTypedObject } from '@sanity/types';
@@ -227,16 +221,18 @@ const genericValidators = {
     return result;
   }
 };
-const booleanValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+const booleanValidators = {
+  ...genericValidators,
   presence: (flag, value, message) => {
     if (flag === "required" && typeof value !== "boolean") {
       return message || "Required";
     }
     return true;
   }
-});
+};
 const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
-const numberValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+const numberValidators = {
+  ...genericValidators,
   integer: (_unused, value, message) => {
     if (!Number.isInteger(value)) {
       return message || "Must be an integer";
@@ -276,11 +272,12 @@ const numberValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     }
     return message || "Must be less than ".concat(maxNum);
   }
-});
+};
 const DUMMY_ORIGIN = "http://sanity";
 const emailRegex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
 const isRelativeUrl = url => /^\.*\//.test(url);
-const stringValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+const stringValidators = {
+  ...genericValidators,
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
@@ -370,8 +367,9 @@ const stringValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     }
     return message || "Must be a valid email address";
   }
-});
-const arrayValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+};
+const arrayValidators = {
+  ...genericValidators,
   min: (minLength, value, message) => {
     if (!value || value.length >= minLength) {
       return true;
@@ -447,9 +445,10 @@ const arrayValidators = _objectSpread(_objectSpread({}, genericValidators), {},
       paths
     }) : true;
   }
-});
+};
 const metaKeys = ["_key", "_type", "_weak"];
-const objectValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+const objectValidators = {
+  ...genericValidators,
   presence: (expected, value, message) => {
     if (expected !== "required") {
       return true;
@@ -495,7 +494,7 @@ const objectValidators = _objectSpread(_objectSpread({}, genericValidators), {},
     }
     return true;
   }
-});
+};
 function isRecord$1(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
@@ -529,7 +528,8 @@ function parseDate(date) {
   }
   return isInvalid ? null : parsed;
 }
-const dateValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
+const dateValidators = {
+  ...genericValidators,
   type: (_unused, value, message) => {
     const strVal = "".concat(value);
     if (!strVal || isoDate.test(value)) {
@@ -567,7 +567,7 @@ const dateValidators = _objectSpread(_objectSpread({}, genericValidators), {}, {
     const date = getFormattedDate(context.type.name, maxDate, dateTimeOptions);
     return message || "Must be at or before ".concat(date);
   }
-});
+};
 var _a;
 const typeValidators = {
   Boolean: booleanValidators,
@@ -596,6 +596,7 @@ const Rule = (_a = class {
     this._message = void 0;
     this._rules = [];
     this._fieldRules = void 0;
+    // Alias to static method, since we often have access to an _instance_ of a rule but not the actual Rule class
     this.valueOfField = _a.valueOfField.bind(_a);
     this._typeDef = typeDef;
     this.reset();
@@ -673,6 +674,7 @@ const Rule = (_a = class {
     newRule._level = this._level === "error" ? rule._level : this._level;
     return newRule;
   }
+  // Validation flag setters
   type(targetType) {
     const type = "".concat(targetType.slice(0, 1).toUpperCase()).concat(targetType.slice(1));
     if (!ruleConstraintTypes$1.includes(type)) {
@@ -697,6 +699,7 @@ const Rule = (_a = class {
       constraint: children
     }]);
   }
+  // Shared rules
   optional() {
     const rule = this.cloneWithRules([{
       flag: "presence",
@@ -744,6 +747,7 @@ const Rule = (_a = class {
       constraint: values
     }]);
   }
+  // Numbers only
   integer() {
     return this.cloneWithRules([{
       flag: "integer"
@@ -779,6 +783,7 @@ const Rule = (_a = class {
       constraint: num
     }]);
   }
+  // String only
   uppercase() {
     return this.cloneWithRules([{
       flag: "stringCasing",
@@ -834,11 +839,13 @@ const Rule = (_a = class {
       constraint
     }]);
   }
+  // Array only
   unique() {
     return this.cloneWithRules([{
       flag: "unique"
     }]);
   }
+  // Objects only
   reference() {
     return this.cloneWithRules([{
       flag: "reference"
@@ -875,7 +882,9 @@ const Rule = (_a = class {
     if (valueIsEmpty && this._required === "optional") {
       return EMPTY_ARRAY;
     }
-    const rules = this._required === void 0 && valueIsEmpty ? this._rules.filter(curr => curr.flag === "custom") : this._rules;
+    const rules =
+    // Run only the _custom_ functions if the rule is not set to required or optional
+    this._required === void 0 && valueIsEmpty ? this._rules.filter(curr => curr.flag === "custom") : this._rules;
     const validators = this._type && typeValidators[this._type] || genericValidators;
     const results = await Promise.all(rules.map(async curr => {
       if (curr.flag === void 0) {
@@ -992,11 +1001,12 @@ const slugValidator = async (value, context) => {
   }
   const options = (_a = context == null ? void 0 : context.type) == null ? void 0 : _a.options;
   const isUnique = (options == null ? void 0 : options.isUnique) || defaultIsUnique;
-  const slugContext = _objectSpread(_objectSpread({}, context), {}, {
+  const slugContext = {
+    ...context,
     parent: context.parent,
     type: context.type,
     defaultIsUnique
-  });
+  };
   const wasUnique = await isUnique(slugValue, slugContext);
   if (wasUnique) {
     return true;
@@ -1024,7 +1034,15 @@ function baseRuleReducer(inputRule, type) {
   if (isRuleConstraint(type.jsonType)) {
     baseRule = baseRule.type(type.jsonType);
   }
-  const typeOptionsList = (type == null ? void 0 : type.options) && typeof type.options === "object" && "list" in type.options && type.options.list;
+  const typeOptionsList =
+  // if type.options is truthy
+  (type == null ? 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)));
   }
@@ -1053,23 +1071,27 @@ function normalizeValidationRules(typeDef) {
   }
   const validation = typeDef.validation;
   if (Array.isArray(validation)) {
-    return validation.flatMap(i => normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
+    return validation.flatMap(i => normalizeValidationRules({
+      ...typeDef,
       validation: i
-    })));
+    }));
   }
   if (validation instanceof Rule) {
     return [validation];
   }
-  const baseRule = Object.values(getTypeChain(typeDef, /* @__PURE__ */new Set()).reduce((acc, type) => {
+  const baseRule =
+  // using an object + Object.values to de-dupe the type chain by type name
+  Object.values(getTypeChain(typeDef, /* @__PURE__ */new Set()).reduce((acc, type) => {
     acc[type.name] = type;
     return acc;
   }, {})).reduce(baseRuleReducer, new Rule(typeDef));
   if (!validation) {
     return [baseRule];
   }
-  return normalizeValidationRules(_objectSpread(_objectSpread({}, typeDef), {}, {
+  return normalizeValidationRules({
+    ...typeDef,
     validation: validation(baseRule)
-  }));
+  });
 }
 const isRecord = maybeRecord => typeof maybeRecord === "object" && maybeRecord !== null && !Array.isArray(maybeRecord);
 const isNonNullable = value => value !== null && value !== void 0;
@@ -1131,22 +1153,25 @@ function validateDocumentObservable(getClient, doc, schema, context) {
 }
 function validateItemObservable(_ref) {
   let {
-      value,
-      type,
-      path = [],
-      parent
-    } = _ref,
-    restOfContext = _objectWithoutProperties(_ref, _excluded);
+    value,
+    type,
+    path = [],
+    parent,
+    ...restOfContext
+  } = _ref;
   var _a;
   const rules = normalizeValidationRules(type);
-  const selfChecks = rules.map(rule => defer(() => rule.validate(value, _objectSpread(_objectSpread({}, restOfContext), {}, {
+  const selfChecks = rules.map(rule => defer(() => rule.validate(value, {
+    ...restOfContext,
     parent,
     path,
     type
-  }))));
+  })));
   let nestedChecks = [];
   const selfIsRequired = rules.some(rule => rule.isRequired());
-  const shouldRunNestedObjectValidation = (type == null ? void 0 : type.jsonType) === "object" && (!!value || (value === null || value === void 0) && selfIsRequired);
+  const shouldRunNestedObjectValidation =
+  // run nested validation for objects
+  (type == null ? void 0 : type.jsonType) === "object" && (!!value || (value === null || value === void 0) && selfIsRequired);
   if (shouldRunNestedObjectValidation) {
     const fieldTypes = type.fields.reduce((acc, field) => {
       acc[field.name] = field.type;
@@ -1155,34 +1180,38 @@ function validateItemObservable(_ref) {
     nestedChecks = nestedChecks.concat(rules.map(rule => rule._fieldRules).filter(isNonNullable).flatMap(fieldResults => Object.entries(fieldResults)).flatMap(_ref2 => {
       let [name, validation] = _ref2;
       const fieldType = fieldTypes[name];
-      return normalizeValidationRules(_objectSpread(_objectSpread({}, fieldType), {}, {
+      return normalizeValidationRules({
+        ...fieldType,
         validation
-      })).map(subRule => {
+      }).map(subRule => {
         const nestedValue = isRecord(value) ? value[name] : void 0;
-        return defer(() => subRule.validate(nestedValue, _objectSpread(_objectSpread({}, restOfContext), {}, {
+        return defer(() => subRule.validate(nestedValue, {
+          ...restOfContext,
           parent: value,
           path: path.concat(name),
           type: fieldType
-        })));
+        }));
       });
     }));
-    nestedChecks = nestedChecks.concat(type.fields.map(field => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
+    nestedChecks = nestedChecks.concat(type.fields.map(field => validateItemObservable({
+      ...restOfContext,
       parent: value,
       value: isRecord(value) ? value[field.name] : void 0,
       path: path.concat(field.name),
       type: field.type
-    }))));
+    })));
   }
   const shouldRunNestedValidationForArrays = (type == null ? void 0 : type.jsonType) === "array" && Array.isArray(value);
   if (shouldRunNestedValidationForArrays) {
-    nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
+    nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable({
+      ...restOfContext,
       parent: value,
       value: item,
       path: path.concat(isKeyedObject(item) ? {
         _key: item._key
       } : index),
       type: resolveTypeForArrayItem(item, type.of)
-    }))));
+    })));
   }
   const shouldRunNestedValidationForMarkDefs = isPortableTextTextBlock(value) && ((_a = value.markDefs) == null ? void 0 : _a.length) && isBlockSchemaType(type);
   if (shouldRunNestedValidationForMarkDefs) {
@@ -1192,14 +1221,15 @@ function validateItemObservable(_ref) {
       acc.set(annotationType.name, annotationType);
       return acc;
     }, /* @__PURE__ */new Map());
-    nestedChecks = nestedChecks.concat((value.markDefs || []).map(markDef => validateItemObservable(_objectSpread(_objectSpread({}, restOfContext), {}, {
+    nestedChecks = nestedChecks.concat((value.markDefs || []).map(markDef => validateItemObservable({
+      ...restOfContext,
       parent: value,
       value: markDef,
       path: path.concat(["markDefs", {
         _key: markDef._key
       }]),
       type: annotations.get(markDef._type)
-    }))));
+    })));
   }
   return defer(() => merge([...selfChecks, ...nestedChecks])).pipe(mergeMap(validateNode => concat(idle(), validateNode), 40), mergeAll(), toArray(), map(flatten), map(results => {
     if (rules.some(rule => rule._fieldRules)) {