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

package/lib/dts/src/ValidationError.js

@@ -1,18 +1,18 @@
 // Follows the same pattern as Rule and RuleClass. @see Rule
 const ValidationError = class ValidationError {
-  constructor(message, options = {}) {
-    this.message = message
-    this.paths = options.paths || []
-    this.children = options.children
-    this.operation = options.operation
-  }
-  cloneWithMessage(msg) {
-    return new ValidationError(msg, {
-      paths: this.paths,
-      children: this.children,
-      operation: this.operation,
-    })
-  }
-}
-export default ValidationError
-//# sourceMappingURL=ValidationError.js.map
+    constructor(message, options = {}) {
+        this.message = message;
+        this.paths = options.paths || [];
+        this.children = options.children;
+        this.operation = options.operation;
+    }
+    cloneWithMessage(msg) {
+        return new ValidationError(msg, {
+            paths: this.paths,
+            children: this.children,
+            operation: this.operation,
+        });
+    }
+};
+export default ValidationError;
+//# sourceMappingURL=ValidationError.js.map

package/lib/dts/src/index.js

@@ -1,7 +1,7 @@
-import RuleClass from './Rule'
-import validateDocument from './validateDocument'
-import inferFromSchema from './inferFromSchema'
-import inferFromSchemaType from './inferFromSchemaType'
-export default {Rule: RuleClass, validateDocument, inferFromSchema, inferFromSchemaType}
-export {RuleClass as Rule, validateDocument, inferFromSchema, inferFromSchemaType}
-//# sourceMappingURL=index.js.map
+import RuleClass from './Rule';
+import validateDocument from './validateDocument';
+import inferFromSchema from './inferFromSchema';
+import inferFromSchemaType from './inferFromSchemaType';
+export default { Rule: RuleClass, validateDocument, inferFromSchema, inferFromSchemaType };
+export { RuleClass as Rule, validateDocument, inferFromSchema, inferFromSchemaType };
+//# sourceMappingURL=index.js.map

package/lib/dts/src/inferFromSchema.js

@@ -1,14 +1,14 @@
-import inferFromSchemaType from './inferFromSchemaType'
+import inferFromSchemaType from './inferFromSchemaType';
 // Note: Mutates schema. Refactor when @sanity/schema supports middlewares
 function inferFromSchema(schema) {
-  const typeNames = schema.getTypeNames()
-  typeNames.forEach((typeName) => {
-    const schemaType = schema.get(typeName)
-    if (schemaType) {
-      inferFromSchemaType(schemaType)
-    }
-  })
-  return schema
+    const typeNames = schema.getTypeNames();
+    typeNames.forEach((typeName) => {
+        const schemaType = schema.get(typeName);
+        if (schemaType) {
+            inferFromSchemaType(schemaType);
+        }
+    });
+    return schema;
 }
-export default inferFromSchema
-//# sourceMappingURL=inferFromSchema.js.map
+export default inferFromSchema;
+//# sourceMappingURL=inferFromSchema.js.map

package/lib/dts/src/inferFromSchemaType.js

@@ -1,33 +1,33 @@
-import normalizeValidationRules from './util/normalizeValidationRules'
+import normalizeValidationRules from './util/normalizeValidationRules';
 function traverse(typeDef, visited) {
-  if (visited.has(typeDef)) {
-    return
-  }
-  visited.add(typeDef)
-  typeDef.validation = normalizeValidationRules(typeDef)
-  if ('fields' in typeDef) {
-    for (const field of typeDef.fields) {
-      traverse(field.type, visited)
+    if (visited.has(typeDef)) {
+        return;
     }
-  }
-  if ('of' in typeDef) {
-    for (const candidate of typeDef.of) {
-      traverse(candidate, visited)
+    visited.add(typeDef);
+    typeDef.validation = normalizeValidationRules(typeDef);
+    if ('fields' in typeDef) {
+        for (const field of typeDef.fields) {
+            traverse(field.type, visited);
+        }
+    }
+    if ('of' in typeDef) {
+        for (const candidate of typeDef.of) {
+            traverse(candidate, visited);
+        }
     }
-  }
-  // 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
-    for (const annotation of typeDef.annotations) {
-      traverse(annotation, visited)
+    if (typeDef.annotations) {
+        // eslint-disable-next-line no-warning-comments
+        // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet
+        for (const annotation of typeDef.annotations) {
+            traverse(annotation, visited);
+        }
     }
-  }
 }
 function inferFromSchemaType(typeDef) {
-  traverse(typeDef, new Set())
-  return typeDef
+    traverse(typeDef, new Set());
+    return typeDef;
 }
-export default inferFromSchemaType
-//# sourceMappingURL=inferFromSchemaType.js.map
+export default inferFromSchemaType;
+//# sourceMappingURL=inferFromSchemaType.js.map

package/lib/dts/src/util/convertToValidationMarker.js

@@ -1,60 +1,51 @@
-import ValidationErrorClass from '../ValidationError'
-import pathToString from '../util/pathToString'
+import ValidationErrorClass from '../ValidationError';
+import pathToString from '../util/pathToString';
 export function isNonNullable(t) {
-  return t !== null || t !== undefined
+    return t !== null || t !== undefined;
 }
 export function convertToValidationMarker(validatorResult, level, context) {
-  if (!context) {
-    throw new Error('missing context')
-  }
-  if (validatorResult === true) return []
-  if (Array.isArray(validatorResult)) {
-    return validatorResult
-      .flatMap((child) => convertToValidationMarker(child, level, context))
-      .filter(isNonNullable)
-  }
-  if (typeof validatorResult === 'string') {
-    return convertToValidationMarker(new ValidationErrorClass(validatorResult), level, context)
-  }
-  if (!(validatorResult instanceof ValidationErrorClass)) {
-    // in order to accept the `ValidationErrorLike`, it at least needs to have
-    // a `message` in the object
-    if (typeof validatorResult?.message !== 'string') {
-      throw new Error(
-        `${pathToString(
-          context.path
-        )}: Validator must return 'true' if valid or an error message as a string on errors`
-      )
+    if (!context) {
+        throw new Error('missing context');
     }
-    // this is the occurs when an object is returned that wasn't created with the
-    // `ValidationErrorClass`. in this case, we want to convert it to a class
-    return convertToValidationMarker(
-      new ValidationErrorClass(validatorResult.message, validatorResult),
-      level,
-      context
-    )
-  }
-  const results = []
-  // the validator result does not include any item-level relative paths,
-  // then just return the top-level path with the validation result
-  if (!validatorResult.paths?.length) {
-    return [
-      {
+    if (validatorResult === true)
+        return [];
+    if (Array.isArray(validatorResult)) {
+        return validatorResult
+            .flatMap((child) => convertToValidationMarker(child, level, context))
+            .filter(isNonNullable);
+    }
+    if (typeof validatorResult === 'string') {
+        return convertToValidationMarker(new ValidationErrorClass(validatorResult), level, context);
+    }
+    if (!(validatorResult instanceof ValidationErrorClass)) {
+        // in order to accept the `ValidationErrorLike`, it at least needs to have
+        // a `message` in the object
+        if (typeof validatorResult?.message !== 'string') {
+            throw new Error(`${pathToString(context.path)}: Validator must return 'true' if valid or an error message as a string on errors`);
+        }
+        // this is the occurs when an object is returned that wasn't created with the
+        // `ValidationErrorClass`. in this case, we want to convert it to a class
+        return convertToValidationMarker(new ValidationErrorClass(validatorResult.message, validatorResult), level, context);
+    }
+    const results = [];
+    // the validator result does not include any item-level relative paths,
+    // then just return the top-level path with the validation result
+    if (!validatorResult.paths?.length) {
+        return [
+            {
+                level: level || 'error',
+                item: validatorResult,
+                path: context.path || [],
+            },
+        ];
+    }
+    // if the validator result did include item-level relative paths, then for
+    // each item-level relative path, create a validation marker that concatenates
+    // the relative path with the path from the validation context
+    return results.concat(validatorResult.paths.map((path) => ({
+        path: (context.path || []).concat(path),
         level: level || 'error',
         item: validatorResult,
-        path: context.path || [],
-      },
-    ]
-  }
-  // if the validator result did include item-level relative paths, then for
-  // each item-level relative path, create a validation marker that concatenates
-  // the relative path with the path from the validation context
-  return results.concat(
-    validatorResult.paths.map((path) => ({
-      path: (context.path || []).concat(path),
-      level: level || 'error',
-      item: validatorResult,
-    }))
-  )
+    })));
 }
-//# sourceMappingURL=convertToValidationMarker.js.map
+//# sourceMappingURL=convertToValidationMarker.js.map

package/lib/dts/src/util/deepEquals.js

@@ -8,57 +8,58 @@
 // control flow branch.
 // see here: https://www.typescriptlang.org/docs/handbook/2/narrowing.html
 export default function deepEquals(a, b) {
-  if (a === b) {
-    return true
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length != b.length) return false
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEquals(a[i], b[i])) {
-        return false
-      }
+    if (a === b) {
+        return true;
     }
-    return true
-  }
-  if (Array.isArray(a) != Array.isArray(b)) {
-    return false
-  }
-  if (a && b && typeof a === 'object' && typeof b === 'object') {
-    const keys = Object.keys(a)
-    if (keys.length !== Object.keys(b).length) {
-      return false
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length != b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
     }
-    if (a instanceof Date && b instanceof Date) {
-      return a.getTime() === b.getTime()
+    if (Array.isArray(a) != Array.isArray(b)) {
+        return false;
     }
-    if (a instanceof Date != b instanceof Date) {
-      return false
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length) {
+            return false;
+        }
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        if (a instanceof Date != b instanceof Date) {
+            return false;
+        }
+        if (a instanceof RegExp && b instanceof RegExp) {
+            return a.toString() == b.toString();
+        }
+        if (a instanceof RegExp != b instanceof RegExp) {
+            return false;
+        }
+        for (let i = 0; i < keys.length; i++) {
+            if (keys[i] === '_key') {
+                continue;
+            }
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+                return false;
+            }
+        }
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key === '_key') {
+                continue;
+            }
+            if (!deepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
     }
-    if (a instanceof RegExp && b instanceof RegExp) {
-      return a.toString() == b.toString()
-    }
-    if (a instanceof RegExp != b instanceof RegExp) {
-      return false
-    }
-    for (let i = 0; i < keys.length; i++) {
-      if (keys[i] === '_key') {
-        continue
-      }
-      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
-        return false
-      }
-    }
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      if (key === '_key') {
-        continue
-      }
-      if (!deepEquals(a[key], b[key])) {
-        return false
-      }
-    }
-    return true
-  }
-  return false
+    return false;
 }
-//# sourceMappingURL=deepEquals.js.map
+//# sourceMappingURL=deepEquals.js.map

package/lib/dts/src/util/escapeRegex.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-useless-escape */
 export default (string) => {
-  // Escape ^$.*+-?=!:|\/()[]{},
-  return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&')
-}
-//# sourceMappingURL=escapeRegex.js.map
+    // Escape ^$.*+-?=!:|\/()[]{},
+    return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&');
+};
+//# sourceMappingURL=escapeRegex.js.map

package/lib/dts/src/util/normalizeValidationRules.js

@@ -1,95 +1,104 @@
-import RuleClass from '../Rule'
-import {slugValidator} from '../validators/slugValidator'
+import RuleClass from '../Rule';
+import { slugValidator } from '../validators/slugValidator';
 const ruleConstraintTypes = {
-  array: true,
-  boolean: true,
-  date: true,
-  number: true,
-  object: true,
-  string: true,
-}
-const isRuleConstraint = (typeString) => typeString in ruleConstraintTypes
+    array: true,
+    boolean: true,
+    date: true,
+    number: true,
+    object: true,
+    string: true,
+};
+const isRuleConstraint = (typeString) => typeString in ruleConstraintTypes;
 function getTypeChain(type, visited) {
-  if (!type) return []
-  if (visited.has(type)) return []
-  visited.add(type)
-  const next = type.type ? getTypeChain(type.type, visited) : []
-  return [...next, type]
+    if (!type)
+        return [];
+    if (visited.has(type))
+        return [];
+    visited.add(type);
+    const next = type.type ? getTypeChain(type.type, visited) : [];
+    return [...next, type];
 }
 function baseRuleReducer(inputRule, type) {
-  let baseRule = inputRule
-  if (isRuleConstraint(type.jsonType)) {
-    baseRule = baseRule.type(type.jsonType)
-  }
-  const typeOptionsList =
+    let baseRule = inputRule;
+    if (isRuleConstraint(type.jsonType)) {
+        baseRule = baseRule.type(type.jsonType);
+    }
+    const typeOptionsList = 
     // if type.options is truthy
     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))
-    )
-  }
-  if (type.name === 'datetime') return baseRule.type('Date')
-  if (type.name === 'date') return baseRule.type('Date')
-  if (type.name === 'url') return baseRule.uri()
-  if (type.name === 'slug') return baseRule.custom(slugValidator)
-  if (type.name === 'reference') return baseRule.reference()
-  if (type.name === 'email') return baseRule.email()
-  return baseRule
+        // 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)));
+    }
+    if (type.name === 'datetime')
+        return baseRule.type('Date');
+    if (type.name === 'date')
+        return baseRule.type('Date');
+    if (type.name === 'url')
+        return baseRule.uri();
+    if (type.name === 'slug')
+        return baseRule.custom(slugValidator);
+    if (type.name === 'reference')
+        return baseRule.reference();
+    if (type.name === 'email')
+        return baseRule.email();
+    return baseRule;
 }
 function hasValueField(typeDef) {
-  if (!typeDef) return false
-  if (!('fields' in typeDef) && typeDef.type) return hasValueField(typeDef.type)
-  if (!('fields' in typeDef)) return false
-  if (!Array.isArray(typeDef.fields)) return false
-  return typeDef.fields.some((field) => field.name === 'value')
+    if (!typeDef)
+        return false;
+    if (!('fields' in typeDef) && typeDef.type)
+        return hasValueField(typeDef.type);
+    if (!('fields' in typeDef))
+        return false;
+    if (!Array.isArray(typeDef.fields))
+        return false;
+    return typeDef.fields.some((field) => field.name === 'value');
 }
 function extractValueFromListOption(option, typeDef) {
-  // If you define a `list` option with object items, where the item has a `value` field,
-  // we don't want to treat that as the value but rather the surrounding object
-  // This differs from the case where you have a title/value pair setup for a string/number, for instance
-  if (typeDef.jsonType === 'object' && hasValueField(typeDef)) return option
-  return option.value === undefined ? option : option.value
+    // If you define a `list` option with object items, where the item has a `value` field,
+    // we don't want to treat that as the value but rather the surrounding object
+    // This differs from the case where you have a title/value pair setup for a string/number, for instance
+    if (typeDef.jsonType === 'object' && hasValueField(typeDef))
+        return option;
+    return option.value === undefined
+        ? option
+        : option.value;
 }
 /**
  * Takes in `SchemaValidationValue` and returns an array of `Rule` instances.
  */
 export default function normalizeValidationRules(typeDef) {
-  if (!typeDef) {
-    return []
-  }
-  const validation = typeDef.validation
-  if (Array.isArray(validation)) {
-    return validation.flatMap((i) =>
-      normalizeValidationRules({
-        ...typeDef,
-        validation: i,
-      })
-    )
-  }
-  if (validation instanceof RuleClass) {
-    return [validation]
-  }
-  const baseRule =
+    if (!typeDef) {
+        return [];
+    }
+    const validation = typeDef.validation;
+    if (Array.isArray(validation)) {
+        return validation.flatMap((i) => normalizeValidationRules({
+            ...typeDef,
+            validation: i,
+        }));
+    }
+    if (validation instanceof RuleClass) {
+        return [validation];
+    }
+    const baseRule = 
     // using an object + Object.values to de-dupe the type chain by type name
-    Object.values(
-      getTypeChain(typeDef, new Set()).reduce((acc, type) => {
-        acc[type.name] = type
-        return acc
-      }, {})
-    ).reduce(baseRuleReducer, new RuleClass(typeDef))
-  if (!validation) {
-    return [baseRule]
-  }
-  return normalizeValidationRules({
-    ...typeDef,
-    validation: validation(baseRule),
-  })
+    Object.values(getTypeChain(typeDef, new Set()).reduce((acc, type) => {
+        acc[type.name] = type;
+        return acc;
+    }, {})).reduce(baseRuleReducer, new RuleClass(typeDef));
+    if (!validation) {
+        return [baseRule];
+    }
+    return normalizeValidationRules({
+        ...typeDef,
+        validation: validation(baseRule),
+    });
 }
-//# sourceMappingURL=normalizeValidationRules.js.map
+//# sourceMappingURL=normalizeValidationRules.js.map

package/lib/dts/src/util/normalizeValidationRules.test.d.ts

@@ -1,2 +1,2 @@
-export {}
-//# sourceMappingURL=normalizeValidationRules.test.d.ts.map
+export {};
+//# sourceMappingURL=normalizeValidationRules.test.d.ts.map