@sanity/validation 2.30.1-purple-unicorn.964 → 3.0.0-dev-preview.0

package/lib/dts/src/validators/arrayValidator.js

@@ -1,79 +1,79 @@
-import deepEquals from '../util/deepEquals'
-import ValidationErrorClass from '../ValidationError'
-import genericValidator from './genericValidator'
+import deepEquals from '../util/deepEquals';
+import ValidationErrorClass from '../ValidationError';
+import genericValidator from './genericValidator';
 const arrayValidators = {
-  ...genericValidator,
-  min: (minLength, value, message) => {
-    if (!value || value.length >= minLength) {
-      return true
-    }
-    return message || `Must have at least ${minLength} items`
-  },
-  max: (maxLength, value, message) => {
-    if (!value || value.length <= maxLength) {
-      return true
-    }
-    return message || `Must have at most ${maxLength} items`
-  },
-  length: (wantedLength, value, message) => {
-    if (!value || value.length === wantedLength) {
-      return true
-    }
-    return message || `Must have exactly ${wantedLength} items`
-  },
-  presence: (flag, value, message) => {
-    if (flag === 'required' && !value) {
-      return message || 'Required'
-    }
-    return true
-  },
-  valid: (allowedValues, values, message) => {
-    const valueType = typeof values
-    if (valueType === 'undefined') {
-      return true
-    }
-    const paths = []
-    for (let i = 0; i < values.length; i++) {
-      const value = values[i]
-      if (allowedValues.some((expected) => deepEquals(expected, value))) {
-        continue
-      }
-      const pathSegment = value && value._key ? {_key: value._key} : i
-      paths.push([pathSegment])
-    }
-    return paths.length === 0
-      ? true
-      : new ValidationErrorClass(message || 'Value did not match any allowed values', {paths})
-  },
-  unique: (_unused, value, message) => {
-    const dupeIndices = []
-    if (!value) {
-      return true
-    }
-    for (let x = 0; x < value.length; x++) {
-      for (let y = x + 1; y < value.length; y++) {
-        const itemA = value[x]
-        const itemB = value[y]
-        if (!deepEquals(itemA, itemB)) {
-          continue
+    ...genericValidator,
+    min: (minLength, value, message) => {
+        if (!value || value.length >= minLength) {
+            return true;
         }
-        if (dupeIndices.indexOf(x) === -1) {
-          dupeIndices.push(x)
+        return message || `Must have at least ${minLength} items`;
+    },
+    max: (maxLength, value, message) => {
+        if (!value || value.length <= maxLength) {
+            return true;
         }
-        if (dupeIndices.indexOf(y) === -1) {
-          dupeIndices.push(y)
+        return message || `Must have at most ${maxLength} items`;
+    },
+    length: (wantedLength, value, message) => {
+        if (!value || value.length === wantedLength) {
+            return true;
         }
-      }
-    }
-    const paths = dupeIndices.map((idx) => {
-      const item = value[idx]
-      const pathSegment = item && item._key ? {_key: item._key} : idx
-      return [pathSegment]
-    })
-    return dupeIndices.length > 0
-      ? new ValidationErrorClass(message || `Can't be a duplicate`, {paths})
-      : true
-  },
-}
-export default arrayValidators
-//# sourceMappingURL=arrayValidator.js.map
+        return message || `Must have exactly ${wantedLength} items`;
+    },
+    presence: (flag, value, message) => {
+        if (flag === 'required' && !value) {
+            return message || 'Required';
+        }
+        return true;
+    },
+    valid: (allowedValues, values, message) => {
+        const valueType = typeof values;
+        if (valueType === 'undefined') {
+            return true;
+        }
+        const paths = [];
+        for (let i = 0; i < values.length; i++) {
+            const value = values[i];
+            if (allowedValues.some((expected) => deepEquals(expected, value))) {
+                continue;
+            }
+            const pathSegment = value && value._key ? { _key: value._key } : i;
+            paths.push([pathSegment]);
+        }
+        return paths.length === 0
+            ? true
+            : new ValidationErrorClass(message || 'Value did not match any allowed values', { paths });
+    },
+    unique: (_unused, value, message) => {
+        const dupeIndices = [];
+        if (!value) {
+            return true;
+        }
+        for (let x = 0; x < value.length; x++) {
+            for (let y = x + 1; y < value.length; y++) {
+                const itemA = value[x];
+                const itemB = value[y];
+                if (!deepEquals(itemA, itemB)) {
+                    continue;
+                }
+                if (dupeIndices.indexOf(x) === -1) {
+                    dupeIndices.push(x);
+                }
+                if (dupeIndices.indexOf(y) === -1) {
+                    dupeIndices.push(y);
+                }
+            }
+        }
+        const paths = dupeIndices.map((idx) => {
+            const item = value[idx];
+            const pathSegment = item && item._key ? { _key: item._key } : idx;
+            return [pathSegment];
+        });
+        return dupeIndices.length > 0
+            ? new ValidationErrorClass(message || `Can't be a duplicate`, { paths })
+            : true;
+    },
+};
+export default arrayValidators;
+//# sourceMappingURL=arrayValidator.js.map

package/lib/dts/src/validators/booleanValidator.js

@@ -1,12 +1,12 @@
-import genericValidator from './genericValidator'
+import genericValidator from './genericValidator';
 const booleanValidators = {
-  ...genericValidator,
-  presence: (flag, value, message) => {
-    if (flag === 'required' && typeof value !== 'boolean') {
-      return message || 'Required'
-    }
-    return true
-  },
-}
-export default booleanValidators
-//# sourceMappingURL=booleanValidator.js.map
+    ...genericValidator,
+    presence: (flag, value, message) => {
+        if (flag === 'required' && typeof value !== 'boolean') {
+            return message || 'Required';
+        }
+        return true;
+    },
+};
+export default booleanValidators;
+//# sourceMappingURL=booleanValidator.js.map

package/lib/dts/src/validators/dateValidator.js

@@ -1,77 +1,83 @@
-import formatDate from 'date-fns/format'
-import genericValidator from './genericValidator'
+import formatDate from 'date-fns/format';
+import genericValidator from './genericValidator';
 export function isRecord(obj) {
-  return typeof obj === 'object' && obj !== null && !Array.isArray(obj)
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
 }
-const isoDate =
-  /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/
+const isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/;
 const getFormattedDate = (type = '', value, options) => {
-  let format = 'yyyy-MM-dd'
-  if (options && options.dateFormat) {
-    format = options.dateFormat
-  }
-  if (type === 'date') {
-    // If the type is date only
-    return formatDate(new Date(value), format)
-  }
-  // If the type is datetime
-  if (options && options.timeFormat) {
-    format += ` ${options.timeFormat}`
-  } else {
-    format += ' HH:mm'
-  }
-  return formatDate(new Date(value), format)
-}
-function parseDate(date, throwOnError = false) {
-  if (!date) return null
-  if (date === 'now') return new Date()
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const parsed = new Date(date)
-  const isInvalid = isNaN(parsed.getTime())
-  if (isInvalid && throwOnError) {
-    throw new Error(`Unable to parse "${date}" to a date`)
-  }
-  return isInvalid ? null : parsed
-}
-const dateValidators = {
-  ...genericValidator,
-  type: (_unused, value, message) => {
-    const strVal = `${value}`
-    if (!strVal || isoDate.test(value)) {
-      return true
+    let format = 'yyyy-MM-dd';
+    if (options && options.dateFormat) {
+        format = options.dateFormat;
     }
-    return message || 'Must be a valid ISO-8601 formatted date string'
-  },
-  min: (minDate, value, message, context) => {
-    const dateVal = parseDate(value)
-    if (!dateVal) {
-      return true // `type()` should catch parse errors
+    if (type === 'date') {
+        // If the type is date only
+        return formatDate(new Date(value), format);
     }
-    if (!value || dateVal >= parseDate(minDate, true)) {
-      return true
+    // If the type is datetime
+    if (options && options.timeFormat) {
+        format += ` ${options.timeFormat}`;
     }
-    if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`)
+    else {
+        format += ' HH:mm';
     }
-    const dateTimeOptions = isRecord(context.type.options) ? context.type.options : {}
-    const date = getFormattedDate(context.type.name, minDate, dateTimeOptions)
-    return message || `Must be at or after ${date}`
-  },
-  max: (maxDate, value, message, context) => {
-    const dateVal = parseDate(value)
-    if (!dateVal) {
-      return true // `type()` should catch parse errors
-    }
-    if (!value || dateVal <= parseDate(maxDate, true)) {
-      return true
-    }
-    if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`)
+    return formatDate(new Date(value), format);
+};
+function parseDate(date, throwOnError = false) {
+    if (!date)
+        return null;
+    if (date === 'now')
+        return new Date();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = new Date(date);
+    const isInvalid = isNaN(parsed.getTime());
+    if (isInvalid && throwOnError) {
+        throw new Error(`Unable to parse "${date}" to a date`);
     }
-    const dateTimeOptions = isRecord(context.type.options) ? context.type.options : {}
-    const date = getFormattedDate(context.type.name, maxDate, dateTimeOptions)
-    return message || `Must be at or before ${date}`
-  },
+    return isInvalid ? null : parsed;
 }
-export default dateValidators
-//# sourceMappingURL=dateValidator.js.map
+const dateValidators = {
+    ...genericValidator,
+    type: (_unused, value, message) => {
+        const strVal = `${value}`;
+        if (!strVal || isoDate.test(value)) {
+            return true;
+        }
+        return message || 'Must be a valid ISO-8601 formatted date string';
+    },
+    min: (minDate, value, message, context) => {
+        const dateVal = parseDate(value);
+        if (!dateVal) {
+            return true; // `type()` should catch parse errors
+        }
+        if (!value || dateVal >= parseDate(minDate, true)) {
+            return true;
+        }
+        if (!context.type) {
+            throw new Error(`\`type\` was not provided in validation context.`);
+        }
+        const dateTimeOptions = isRecord(context.type.options)
+            ? context.type.options
+            : {};
+        const date = getFormattedDate(context.type.name, minDate, dateTimeOptions);
+        return message || `Must be at or after ${date}`;
+    },
+    max: (maxDate, value, message, context) => {
+        const dateVal = parseDate(value);
+        if (!dateVal) {
+            return true; // `type()` should catch parse errors
+        }
+        if (!value || dateVal <= parseDate(maxDate, true)) {
+            return true;
+        }
+        if (!context.type) {
+            throw new Error(`\`type\` was not provided in validation context.`);
+        }
+        const dateTimeOptions = isRecord(context.type.options)
+            ? context.type.options
+            : {};
+        const date = getFormattedDate(context.type.name, maxDate, dateTimeOptions);
+        return message || `Must be at or before ${date}`;
+    },
+};
+export default dateValidators;
+//# sourceMappingURL=dateValidator.js.map

package/lib/dts/src/validators/genericValidator.js

@@ -1,91 +1,93 @@
-import typeString from '../util/typeString'
-import deepEquals from '../util/deepEquals'
-import pathToString from '../util/pathToString'
-import ValidationErrorClass from '../ValidationError'
-const SLOW_VALIDATOR_TIMEOUT = 5000
+import typeString from '../util/typeString';
+import deepEquals from '../util/deepEquals';
+import pathToString from '../util/pathToString';
+import ValidationErrorClass from '../ValidationError';
+const SLOW_VALIDATOR_TIMEOUT = 5000;
 const formatValidationErrors = (options) => {
-  let message
-  if (options.message) {
-    message = options.message
-  } else if (options.results.length === 1) {
-    message = options.results[0]?.item.message
-  } else {
-    message = `[${options.results
-      .map((err) => err.item.message)
-      .join(` - ${options.operation} - `)}]`
-  }
-  return new ValidationErrorClass(message, {
-    children: options.results.length > 1 ? options.results : undefined,
-    operation: options.operation,
-  })
-}
-const genericValidators = {
-  type: (expected, value, message) => {
-    const actualType = typeString(value)
-    if (actualType !== expected && actualType !== 'undefined') {
-      return message || `Expected type "${expected}", got "${actualType}"`
-    }
-    return true
-  },
-  presence: (expected, value, message) => {
-    if (value === undefined && expected === 'required') {
-      return message || 'Value is required'
+    let message;
+    if (options.message) {
+        message = options.message;
     }
-    return true
-  },
-  all: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)))
-    const results = resolved.flat()
-    if (!results.length) return true
-    return formatValidationErrors({
-      message,
-      results,
-      operation: 'AND',
-    })
-  },
-  either: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)))
-    const results = resolved.flat()
-    // Read: There is at least one rule that matched
-    if (results.length < children.length) return true
-    return formatValidationErrors({
-      message,
-      results,
-      operation: 'OR',
-    })
-  },
-  valid: (allowedValues, actual, message) => {
-    const valueType = typeof actual
-    if (valueType === 'undefined') {
-      return true
+    else if (options.results.length === 1) {
+        message = options.results[0]?.item.message;
     }
-    const value = (valueType === 'number' || valueType === 'string') && `${actual}`
-    const strValue = value && value.length > 30 ? `${value.slice(0, 30)}…` : value
-    const defaultMessage = value
-      ? `Value "${strValue}" did not match any allowed values`
-      : 'Value did not match any allowed values'
-    return allowedValues.some((expected) => deepEquals(expected, actual))
-      ? true
-      : message || defaultMessage
-  },
-  custom: async (fn, value, message, context) => {
-    const slowTimer = setTimeout(() => {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `Custom validator at ${pathToString(
-          context.path
-        )} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`
-      )
-    }, SLOW_VALIDATOR_TIMEOUT)
-    let result
-    try {
-      result = await fn(value, context)
-    } finally {
-      clearTimeout(slowTimer)
+    else {
+        message = `[${options.results
+            .map((err) => err.item.message)
+            .join(` - ${options.operation} - `)}]`;
     }
-    if (typeof result === 'string') return message || result
-    return result
-  },
-}
-export default genericValidators
-//# sourceMappingURL=genericValidator.js.map
+    return new ValidationErrorClass(message, {
+        children: options.results.length > 1 ? options.results : undefined,
+        operation: options.operation,
+    });
+};
+const genericValidators = {
+    type: (expected, value, message) => {
+        const actualType = typeString(value);
+        if (actualType !== expected && actualType !== 'undefined') {
+            return message || `Expected type "${expected}", got "${actualType}"`;
+        }
+        return true;
+    },
+    presence: (expected, value, message) => {
+        if (value === undefined && expected === 'required') {
+            return message || 'Value is required';
+        }
+        return true;
+    },
+    all: async (children, value, message, context) => {
+        const resolved = await Promise.all(children.map((child) => child.validate(value, context)));
+        const results = resolved.flat();
+        if (!results.length)
+            return true;
+        return formatValidationErrors({
+            message,
+            results,
+            operation: 'AND',
+        });
+    },
+    either: async (children, value, message, context) => {
+        const resolved = await Promise.all(children.map((child) => child.validate(value, context)));
+        const results = resolved.flat();
+        // Read: There is at least one rule that matched
+        if (results.length < children.length)
+            return true;
+        return formatValidationErrors({
+            message,
+            results,
+            operation: 'OR',
+        });
+    },
+    valid: (allowedValues, actual, message) => {
+        const valueType = typeof actual;
+        if (valueType === 'undefined') {
+            return true;
+        }
+        const value = (valueType === 'number' || valueType === 'string') && `${actual}`;
+        const strValue = value && value.length > 30 ? `${value.slice(0, 30)}…` : value;
+        const defaultMessage = value
+            ? `Value "${strValue}" did not match any allowed values`
+            : 'Value did not match any allowed values';
+        return allowedValues.some((expected) => deepEquals(expected, actual))
+            ? true
+            : message || defaultMessage;
+    },
+    custom: async (fn, value, message, context) => {
+        const slowTimer = setTimeout(() => {
+            // eslint-disable-next-line no-console
+            console.warn(`Custom validator at ${pathToString(context.path)} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`);
+        }, SLOW_VALIDATOR_TIMEOUT);
+        let result;
+        try {
+            result = await fn(value, context);
+        }
+        finally {
+            clearTimeout(slowTimer);
+        }
+        if (typeof result === 'string')
+            return message || result;
+        return result;
+    },
+};
+export default genericValidators;
+//# sourceMappingURL=genericValidator.js.map

package/lib/dts/src/validators/numberValidator.js

@@ -1,49 +1,47 @@
-import genericValidator from './genericValidator'
-const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/
+import genericValidator from './genericValidator';
+const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
 const numberValidators = {
-  ...genericValidator,
-  integer: (_unused, value, message) => {
-    if (!Number.isInteger(value)) {
-      return message || 'Must be an integer'
-    }
-    return true
-  },
-  precision: (limit, value, message) => {
-    if (value === undefined) return true
-    const places = value.toString().match(precisionRx)
-    const decimals = Math.max(
-      (places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0),
-      0
-    )
-    if (decimals > limit) {
-      return message || `Max precision is ${limit}`
-    }
-    return true
-  },
-  min: (minNum, value, message) => {
-    if (value >= minNum) {
-      return true
-    }
-    return message || `Must be greater than or equal ${minNum}`
-  },
-  max: (maxNum, value, message) => {
-    if (value <= maxNum) {
-      return true
-    }
-    return message || `Must be less than or equal ${maxNum}`
-  },
-  greaterThan: (num, value, message) => {
-    if (value > num) {
-      return true
-    }
-    return message || `Must be greater than ${num}`
-  },
-  lessThan: (maxNum, value, message) => {
-    if (value < maxNum) {
-      return true
-    }
-    return message || `Must be less than ${maxNum}`
-  },
-}
-export default numberValidators
-//# sourceMappingURL=numberValidator.js.map
+    ...genericValidator,
+    integer: (_unused, value, message) => {
+        if (!Number.isInteger(value)) {
+            return message || 'Must be an integer';
+        }
+        return true;
+    },
+    precision: (limit, value, message) => {
+        if (value === undefined)
+            return true;
+        const places = value.toString().match(precisionRx);
+        const decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+        if (decimals > limit) {
+            return message || `Max precision is ${limit}`;
+        }
+        return true;
+    },
+    min: (minNum, value, message) => {
+        if (value >= minNum) {
+            return true;
+        }
+        return message || `Must be greater than or equal ${minNum}`;
+    },
+    max: (maxNum, value, message) => {
+        if (value <= maxNum) {
+            return true;
+        }
+        return message || `Must be less than or equal ${maxNum}`;
+    },
+    greaterThan: (num, value, message) => {
+        if (value > num) {
+            return true;
+        }
+        return message || `Must be greater than ${num}`;
+    },
+    lessThan: (maxNum, value, message) => {
+        if (value < maxNum) {
+            return true;
+        }
+        return message || `Must be less than ${maxNum}`;
+    },
+};
+export default numberValidators;
+//# sourceMappingURL=numberValidator.js.map