@sanity/validation 3.14.4 → 6.12.0-next.46

package/src/util/normalizeValidationRules.test.ts

@@ -1,170 +0,0 @@
-import {NumberSchemaType, SchemaType, StringSchemaType} from '@sanity/types'
-import RuleClass from '../Rule'
-import normalizeValidationRules from './normalizeValidationRules'
-
-describe('normalizeValidationRules', () => {
-  // see `infer.test.ts` for more related tests.
-  // note the Schema.compile runs this function indirectly via `inferFromSchema`
-  it('utilizes schema types to infer base rules', () => {
-    const coolNumberType: NumberSchemaType = {
-      jsonType: 'number',
-      name: 'coolNumber',
-    }
-
-    const rules = normalizeValidationRules(coolNumberType)
-    expect(rules).toHaveLength(1)
-    const [rule] = rules
-
-    expect(rule).toBeInstanceOf(RuleClass)
-    expect(rule._rules).toMatchObject([
-      {
-        constraint: 'Number',
-        flag: 'type',
-      },
-    ])
-  })
-
-  it('follows the type chain to determine the base rule', () => {
-    const sickDatetime = {
-      type: {
-        type: {
-          jsonType: 'string',
-        },
-        name: 'datetime',
-      },
-      name: 'sickDatetime',
-    }
-
-    const rules = normalizeValidationRules(sickDatetime as SchemaType)
-    expect(rules).toHaveLength(1)
-    const [rule] = rules
-
-    // type chain is applied from inner to outer so the resulting type should be
-    // date instead of string
-    expect(rule._rules).toMatchObject([
-      {
-        constraint: 'Date',
-        flag: 'type',
-      },
-    ])
-  })
-
-  it('converts a validation function to a rule instance', () => {
-    const coolStringType: StringSchemaType = {
-      jsonType: 'string',
-      name: 'coolString',
-      validation: (rule) => rule.uppercase(),
-    }
-
-    const rules = normalizeValidationRules(coolStringType)
-    expect(rules).toHaveLength(1)
-    const [rule] = rules
-
-    expect(rule).toBeInstanceOf(RuleClass)
-    expect(rule._rules).toMatchObject([
-      {
-        constraint: 'String',
-        flag: 'type',
-      },
-      {
-        constraint: 'uppercase',
-        flag: 'stringCasing',
-      },
-    ])
-  })
-
-  it('converts falsy values to an empty array', () => {
-    expect(normalizeValidationRules(undefined)).toEqual([])
-  })
-
-  it('converts schema list options with titles to `rule.valid` constraints', () => {
-    const stringTypeWithOptions: StringSchemaType = {
-      jsonType: 'string',
-      name: 'stringTypeWithOptions',
-      options: {
-        list: [
-          {title: 'Blue', value: 'blue'},
-          {title: 'Red', value: 'red'},
-        ],
-      },
-    }
-
-    const rules = normalizeValidationRules(stringTypeWithOptions)
-    expect(rules).toHaveLength(1)
-    const [rule] = rules
-
-    expect(rule).toBeInstanceOf(RuleClass)
-    expect(rule._rules).toMatchObject([
-      {
-        constraint: 'String',
-        flag: 'type',
-      },
-      {
-        constraint: ['blue', 'red'],
-        flag: 'valid',
-      },
-    ])
-  })
-
-  it('converts schema list options with strings only to `rule.valid` constraints', () => {
-    const stringTypeWithOptions: StringSchemaType = {
-      jsonType: 'string',
-      name: 'stringTypeWithOptions',
-      options: {
-        list: ['blue', 'red'],
-      },
-    }
-
-    const rules = normalizeValidationRules(stringTypeWithOptions)
-    expect(rules).toHaveLength(1)
-    const [rule] = rules
-
-    expect(rule).toBeInstanceOf(RuleClass)
-    expect(rule._rules).toMatchObject([
-      {
-        constraint: 'String',
-        flag: 'type',
-      },
-      {
-        constraint: ['blue', 'red'],
-        flag: 'valid',
-      },
-    ])
-  })
-
-  it('converts arrays of validation', () => {
-    const coolNumberType: NumberSchemaType = {
-      jsonType: 'number',
-      name: 'coolNumber',
-      validation: [(rule) => rule.greaterThan(3), RuleClass.number().lessThan(5)],
-    }
-
-    const rules = normalizeValidationRules(coolNumberType)
-    expect(rules).toHaveLength(2)
-    const [first, second] = rules
-
-    expect(first).toBeInstanceOf(RuleClass)
-    expect(first._rules).toMatchObject([
-      {
-        constraint: 'Number',
-        flag: 'type',
-      },
-      {
-        constraint: 3,
-        flag: 'greaterThan',
-      },
-    ])
-
-    expect(second).toBeInstanceOf(RuleClass)
-    expect(second._rules).toMatchObject([
-      {
-        constraint: 'Number',
-        flag: 'type',
-      },
-      {
-        constraint: 5,
-        flag: 'lessThan',
-      },
-    ])
-  })
-})

package/src/util/normalizeValidationRules.ts

@@ -1,118 +0,0 @@
-import {SchemaType, Rule, RuleTypeConstraint} from '@sanity/types'
-import RuleClass from '../Rule'
-import {slugValidator} from '../validators/slugValidator'
-
-const ruleConstraintTypes: {[P in Lowercase<RuleTypeConstraint>]: true} = {
-  array: true,
-  boolean: true,
-  date: true,
-  number: true,
-  object: true,
-  string: true,
-}
-
-const isRuleConstraint = (typeString: string): typeString is Lowercase<RuleTypeConstraint> =>
-  typeString in ruleConstraintTypes
-
-function getTypeChain(type: SchemaType | undefined, visited: Set<SchemaType>): SchemaType[] {
-  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: Rule, type: SchemaType) {
-  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
-}
-
-function hasValueField(typeDef: SchemaType | undefined): boolean {
-  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: unknown, typeDef: SchemaType): unknown {
-  // 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 as Record<string, unknown>).value === undefined
-    ? option
-    : (option as Record<string, unknown>).value
-}
-
-/**
- * Takes in `SchemaValidationValue` and returns an array of `Rule` instances.
- */
-export default function normalizeValidationRules(typeDef: SchemaType | undefined): Rule[] {
-  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<Record<string, SchemaType>>((acc, type) => {
-        acc[type.name] = type
-        return acc
-      }, {})
-    ).reduce(baseRuleReducer, new RuleClass(typeDef))
-
-  if (!validation) {
-    return [baseRule]
-  }
-
-  return normalizeValidationRules({
-    ...typeDef,
-    validation: validation(baseRule),
-  })
-}

package/src/util/pathToString.ts

@@ -1,21 +0,0 @@
-import {Path, isKeyedObject} from '@sanity/types'
-
-export default function pathToString(path: Path | undefined = []): string {
-  return path.reduce<string>((target, segment, i) => {
-    const segmentType = typeof segment
-    if (segmentType === 'number') {
-      return `${target}[${segment}]`
-    }
-
-    if (segmentType === 'string') {
-      const separator = i === 0 ? '' : '.'
-      return `${target}${separator}${segment}`
-    }
-
-    if (isKeyedObject(segment)) {
-      return `${target}[_key=="${segment._key}"]`
-    }
-
-    throw new Error(`Unsupported path segment "${segment}"`)
-  }, '')
-}

package/src/util/requestIdleCallback.ts

@@ -1,31 +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)
-}
-
-const win = typeof window === 'undefined' ? undefined : window
-
-export const requestIdleCallback = win?.requestIdleCallback || requestIdleCallbackShim
-export const cancelIdleCallback = win?.cancelIdleCallback || cancelIdleCallbackShim

package/src/util/typeString.test.ts

@@ -1,27 +0,0 @@
-import typeString from './typeString'
-
-describe('typeString', () => {
-  it('returns the a type string of built in types', () => {
-    expect(typeString({})).toBe('Object')
-    expect(
-      typeString(function () {
-        // intentionally blank
-      })
-    ).toBe('Function')
-    expect(typeString(['hey'])).toBe('Array')
-    expect(typeString('some string')).toBe('String')
-    expect(typeString(false)).toBe('Boolean')
-    expect(typeString(5)).toBe('Number')
-    expect(typeString(new Date())).toBe('Date')
-  })
-
-  it('returns a type string string using the constructor', () => {
-    class ExampleClass {}
-    expect(typeString(new ExampleClass())).toBe('ExampleClass')
-  })
-
-  it('returns a type string for null or undefined', () => {
-    expect(typeString(null)).toBe('null')
-    expect(typeString(undefined)).toBe('undefined')
-  })
-})

package/src/util/typeString.ts

@@ -1,23 +0,0 @@
-// this file was adapted from a previous dependency `type-of-is`
-// https://github.com/stephenhandley/type-of-is/blob/7138a7e79f5af7c286bf8123f60843a91aaebf38/index.js
-const _toString = {}.toString
-
-const builtIns = [Object, Function, Array, String, Boolean, Number, Date, RegExp, Error]
-
-function isBuiltIn(_constructor: unknown) {
-  for (let i = 0; i < builtIns.length; i++) {
-    if (builtIns[i] === _constructor) return true
-  }
-  return false
-}
-
-export default function typeString(obj: unknown): string {
-  // [object Blah] -> Blah
-  const stringType = _toString.call(obj).slice(8, -1)
-  if (obj === null || obj === undefined) return stringType.toLowerCase()
-
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  const constructorType = (obj as object).constructor
-  if (constructorType && !isBuiltIn(constructorType)) return constructorType.name
-  return stringType
-}