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

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

@@ -1,150 +1,150 @@
-import RuleClass from '../Rule'
-import normalizeValidationRules from './normalizeValidationRules'
+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 = {
-      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)
-    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 = {
-      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 = {
-      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 = {
-      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 = {
-      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',
-      },
-    ])
-  })
-})
-//# sourceMappingURL=normalizeValidationRules.test.js.map
+    // 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 = {
+            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);
+        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 = {
+            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 = {
+            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 = {
+            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 = {
+            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',
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=normalizeValidationRules.test.js.map

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

@@ -1,18 +1,18 @@
-import {isKeyedObject} from '@sanity/types'
+import { isKeyedObject } from '@sanity/types';
 export default function pathToString(path = []) {
-  return path.reduce((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}"`)
-  }, '')
+    return path.reduce((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}"`);
+    }, '');
 }
-//# sourceMappingURL=pathToString.js.map
+//# sourceMappingURL=pathToString.js.map

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

@@ -1,20 +1,23 @@
 // 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]
+const _toString = {}.toString;
+const builtIns = [Object, Function, Array, String, Boolean, Number, Date, RegExp, Error];
 function isBuiltIn(_constructor) {
-  for (let i = 0; i < builtIns.length; i++) {
-    if (builtIns[i] === _constructor) return true
-  }
-  return false
+    for (let i = 0; i < builtIns.length; i++) {
+        if (builtIns[i] === _constructor)
+            return true;
+    }
+    return false;
 }
 export default function typeString(obj) {
-  // [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.constructor
-  if (constructorType && !isBuiltIn(constructorType)) return constructorType.name
-  return stringType
+    // [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.constructor;
+    if (constructorType && !isBuiltIn(constructorType))
+        return constructorType.name;
+    return stringType;
 }
-//# sourceMappingURL=typeString.js.map
+//# sourceMappingURL=typeString.js.map

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

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

package/lib/dts/src/util/typeString.test.js

@@ -1,25 +1,24 @@
-import typeString from './typeString'
+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')
-  })
-})
-//# sourceMappingURL=typeString.test.js.map
+    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');
+    });
+});
+//# sourceMappingURL=typeString.test.js.map