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

package/lib/dts/test/children.test.js

@@ -1,88 +1,70 @@
-import {Rule} from '../src'
-const context = {client: {}}
+import { Rule } from '../src';
+const context = { client: {} };
 describe('child rules', () => {
-  // --- ALL ---
-  test('all() rules - single failure', async () => {
-    const rule = Rule.string().all([
-      Rule.string()
-        .regex(/^[A-Z]/)
-        .error('Must start with an uppercase character'),
-      Rule.string()
-        .regex(/[a-z]+/)
-        .error('Must follow with lowercase characters'),
-    ])
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('all() rules - match')
-    await expect(rule.validate('moop', context)).resolves.toMatchSnapshot(
-      'all() rules - single failure, custom message'
-    )
-  })
-  test('all() rules - multiple failures', async () => {
-    const rule = Rule.string().all([
-      Rule.string()
-        .regex(/^[A-Z]/)
-        .error('Must start with an uppercase character'),
-      Rule.string().min(5).error('5 chars or more'),
-      Rule.string()
-        .regex(/[a-z]+/)
-        .error('Must follow with lowercase characters'),
-    ])
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('all() rules - match')
-    await expect(rule.validate('moop', context)).resolves.toMatchSnapshot(
-      'all() rules - multiple failures, custom messages'
-    )
-  })
-  test('all() rules - single failure, custom, common error', async () => {
-    const rule = Rule.string()
-      .all([Rule.string().regex(/^[A-Z]/), Rule.string().regex(/[a-z]+/)])
-      .error('Needs to start with a capital letter and then follow with lowercase characters')
-    await expect(rule.validate('moop', context)).resolves.toMatchSnapshot(
-      'all() rules - single failure, common error'
-    )
-  })
-  test('all() rules - single failure, custom, common error', async () => {
-    const rule = Rule.string()
-      .all([Rule.string().regex(/^[A-Z]/), Rule.string().min(5), Rule.string().regex(/[a-z]+/)])
-      .error('Needs to be a capital letter followed by at least 4 lowercase characters')
-    await expect(rule.validate('moop', context)).resolves.toMatchSnapshot(
-      'all() rules - multiple failures, common error'
-    )
-  })
-  // --- EITHER ---
-  test('either() rules - single failure', async () => {
-    const rule = Rule.string().either([
-      Rule.string()
-        .regex(/^rgb(\d+,\s*\d+,\s*\d+)$/)
-        .error('Must be rgb(num, num, num) format'),
-      Rule.string()
-        .regex(/^#([a-f0-9]{3}|[a-f0-9]{6})$/)
-        .error('Must be hex color with #-prefix'),
-    ])
-    await expect(rule.validate('rgb(16, 22, 133)', context)).resolves.toMatchSnapshot(
-      'either() rules - match'
-    )
-    await expect(rule.validate('#bf', context)).resolves.toMatchSnapshot(
-      'either() rules - single failure, custom message'
-    )
-  })
-  test('either() rules - all matches', async () => {
-    const rule = Rule.string().either([
-      Rule.string().regex(/^R/).error('Must start with a capital R'),
-      Rule.string().regex(/ed$/).error('Must end with "ed"'),
-    ])
-    await expect(rule.validate('Red', context)).resolves.toMatchSnapshot(
-      'either() rules - all match'
-    )
-    await expect(rule.validate('nope', context)).resolves.toMatchSnapshot(
-      'either() rules - no matches'
-    )
-  })
-  test('either() rules - all fail, custom, common error', async () => {
-    const rule = Rule.string()
-      .either([Rule.string().regex(/^[A-Z]/), Rule.string().regex(/^i[A-Z]/)])
-      .error("Needs to start with a capital letter, unless it's an iProduct")
-    await expect(rule.validate('mopatis!', context)).resolves.toMatchSnapshot(
-      'either() rules - all fail, common error'
-    )
-  })
-})
-//# sourceMappingURL=children.test.js.map
+    // --- ALL ---
+    test('all() rules - single failure', async () => {
+        const rule = Rule.string().all([
+            Rule.string()
+                .regex(/^[A-Z]/)
+                .error('Must start with an uppercase character'),
+            Rule.string()
+                .regex(/[a-z]+/)
+                .error('Must follow with lowercase characters'),
+        ]);
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('all() rules - match');
+        await expect(rule.validate('moop', context)).resolves.toMatchSnapshot('all() rules - single failure, custom message');
+    });
+    test('all() rules - multiple failures', async () => {
+        const rule = Rule.string().all([
+            Rule.string()
+                .regex(/^[A-Z]/)
+                .error('Must start with an uppercase character'),
+            Rule.string().min(5).error('5 chars or more'),
+            Rule.string()
+                .regex(/[a-z]+/)
+                .error('Must follow with lowercase characters'),
+        ]);
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('all() rules - match');
+        await expect(rule.validate('moop', context)).resolves.toMatchSnapshot('all() rules - multiple failures, custom messages');
+    });
+    test('all() rules - single failure, custom, common error', async () => {
+        const rule = Rule.string()
+            .all([Rule.string().regex(/^[A-Z]/), Rule.string().regex(/[a-z]+/)])
+            .error('Needs to start with a capital letter and then follow with lowercase characters');
+        await expect(rule.validate('moop', context)).resolves.toMatchSnapshot('all() rules - single failure, common error');
+    });
+    test('all() rules - single failure, custom, common error', async () => {
+        const rule = Rule.string()
+            .all([Rule.string().regex(/^[A-Z]/), Rule.string().min(5), Rule.string().regex(/[a-z]+/)])
+            .error('Needs to be a capital letter followed by at least 4 lowercase characters');
+        await expect(rule.validate('moop', context)).resolves.toMatchSnapshot('all() rules - multiple failures, common error');
+    });
+    // --- EITHER ---
+    test('either() rules - single failure', async () => {
+        const rule = Rule.string().either([
+            Rule.string()
+                .regex(/^rgb(\d+,\s*\d+,\s*\d+)$/)
+                .error('Must be rgb(num, num, num) format'),
+            Rule.string()
+                .regex(/^#([a-f0-9]{3}|[a-f0-9]{6})$/)
+                .error('Must be hex color with #-prefix'),
+        ]);
+        await expect(rule.validate('rgb(16, 22, 133)', context)).resolves.toMatchSnapshot('either() rules - match');
+        await expect(rule.validate('#bf', context)).resolves.toMatchSnapshot('either() rules - single failure, custom message');
+    });
+    test('either() rules - all matches', async () => {
+        const rule = Rule.string().either([
+            Rule.string().regex(/^R/).error('Must start with a capital R'),
+            Rule.string().regex(/ed$/).error('Must end with "ed"'),
+        ]);
+        await expect(rule.validate('Red', context)).resolves.toMatchSnapshot('either() rules - all match');
+        await expect(rule.validate('nope', context)).resolves.toMatchSnapshot('either() rules - no matches');
+    });
+    test('either() rules - all fail, custom, common error', async () => {
+        const rule = Rule.string()
+            .either([Rule.string().regex(/^[A-Z]/), Rule.string().regex(/^i[A-Z]/)])
+            .error("Needs to start with a capital letter, unless it's an iProduct");
+        await expect(rule.validate('mopatis!', context)).resolves.toMatchSnapshot('either() rules - all fail, common error');
+    });
+});
+//# sourceMappingURL=children.test.js.map

package/lib/dts/test/createSchema.d.ts

@@ -1,3 +1,6 @@
-import {Schema} from '@sanity/types'
-export declare function createSchema(schemaDef: {name?: string; types: any[]}): Schema
-//# sourceMappingURL=createSchema.d.ts.map
+import { Schema } from '@sanity/types';
+export declare function createSchema(schemaDef: {
+    name?: string;
+    types: any[];
+}): Schema;
+//# sourceMappingURL=createSchema.d.ts.map

package/lib/dts/test/createSchema.js

@@ -1,19 +1,19 @@
-import SchemaBuilder from '@sanity/schema'
-import {validateSchema, groupProblems} from '@sanity/schema/_internal'
+import SchemaBuilder from '@sanity/schema';
+import { validateSchema, groupProblems } from '@sanity/schema/_internal';
 export function createSchema(schemaDef) {
-  const validated = validateSchema(schemaDef.types).getTypes()
-  const validation = groupProblems(validated)
-  const types = [...schemaDef.types]
-  // Add builtin types
-  types.push({type: 'object', name: 'slug'})
-  // if (!types.find((t) => t.name === 'slug')) {
-  //   types.push()
-  // }
-  const schema = SchemaBuilder.compile({
-    name: schemaDef.name || 'default',
-    types,
-  })
-  schema._validation = validation
-  return schema
+    const validated = validateSchema(schemaDef.types).getTypes();
+    const validation = groupProblems(validated);
+    const types = [...schemaDef.types];
+    // Add builtin types
+    types.push({ type: 'object', name: 'slug' });
+    // if (!types.find((t) => t.name === 'slug')) {
+    //   types.push()
+    // }
+    const schema = SchemaBuilder.compile({
+        name: schemaDef.name || 'default',
+        types,
+    });
+    schema._validation = validation;
+    return schema;
 }
-//# sourceMappingURL=createSchema.js.map
+//# sourceMappingURL=createSchema.js.map

package/lib/dts/test/generics.test.d.ts

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

package/lib/dts/test/generics.test.js

@@ -1,60 +1,60 @@
-import {Rule} from '../src'
-const context = {client: {}}
+import { Rule } from '../src';
+const context = { client: {} };
 describe('generics', () => {
-  test('should be able to construct an empty rule', () => {
-    expect(() => new Rule()).not.toThrow(Error)
-    expect(new Rule()).toBeInstanceOf(Rule)
-  })
-  test('should be able to construct a new typed rule', () => {
-    expect(Rule.string()).toBeInstanceOf(Rule)
-  })
-  test('clones rule when changing generics', () => {
-    const baseRule = new Rule()
-    const typed = baseRule.type('string')
-    expect(baseRule).not.toBe(typed)
-  })
-  test('clones rule when changing type-specific rules', () => {
-    const baseRule = Rule.string()
-    const specific = baseRule.min(5)
-    expect(baseRule).not.toBe(specific)
-  })
-  test('returns arrays of errors/warnings by default', async () => {
-    await expect(Rule.string().validate(123, context)).resolves.toMatchSnapshot()
-  })
-  test('can demote errors to warnings', async () => {
-    const result = await Rule.string().warning().validate(123, context)
-    expect(result).toMatchSnapshot()
-  })
-  test('can customize error messages', async () => {
-    const result = await Rule.string().error('Dude it needs to be a string').validate(123, context)
-    expect(result).toMatchSnapshot()
-  })
-  test('can customize warning messages', async () => {
-    const result = await Rule.string()
-      .warning('Dude it should probably be a string')
-      .validate(123, context)
-    expect(result).toMatchSnapshot()
-  })
-  test('can customize info messages', async () => {
-    const result = await Rule.string()
-      .info('Dude it should probably be a string')
-      .validate(123, context)
-    expect(result).toMatchSnapshot()
-  })
-  test('can merge rules', async () => {
-    const rule = new Rule().required()
-    const stringRule = Rule.string().min(5)
-    const newRule = rule.merge(stringRule)
-    expect(rule).not.toBe(stringRule)
-    expect(newRule).not.toBe(stringRule)
-    expect(rule).not.toBe(newRule)
-    const result = await newRule.validate('Hei', context)
-    expect(result).toMatchSnapshot()
-  })
-  test('can merge rules', () => {
-    expect(new Rule().required().isRequired()).toBe(true)
-    expect(new Rule().isRequired()).toBe(false)
-    expect(new Rule().optional().isRequired()).toBe(false)
-  })
-})
-//# sourceMappingURL=generics.test.js.map
+    test('should be able to construct an empty rule', () => {
+        expect(() => new Rule()).not.toThrow(Error);
+        expect(new Rule()).toBeInstanceOf(Rule);
+    });
+    test('should be able to construct a new typed rule', () => {
+        expect(Rule.string()).toBeInstanceOf(Rule);
+    });
+    test('clones rule when changing generics', () => {
+        const baseRule = new Rule();
+        const typed = baseRule.type('string');
+        expect(baseRule).not.toBe(typed);
+    });
+    test('clones rule when changing type-specific rules', () => {
+        const baseRule = Rule.string();
+        const specific = baseRule.min(5);
+        expect(baseRule).not.toBe(specific);
+    });
+    test('returns arrays of errors/warnings by default', async () => {
+        await expect(Rule.string().validate(123, context)).resolves.toMatchSnapshot();
+    });
+    test('can demote errors to warnings', async () => {
+        const result = await Rule.string().warning().validate(123, context);
+        expect(result).toMatchSnapshot();
+    });
+    test('can customize error messages', async () => {
+        const result = await Rule.string().error('Dude it needs to be a string').validate(123, context);
+        expect(result).toMatchSnapshot();
+    });
+    test('can customize warning messages', async () => {
+        const result = await Rule.string()
+            .warning('Dude it should probably be a string')
+            .validate(123, context);
+        expect(result).toMatchSnapshot();
+    });
+    test('can customize info messages', async () => {
+        const result = await Rule.string()
+            .info('Dude it should probably be a string')
+            .validate(123, context);
+        expect(result).toMatchSnapshot();
+    });
+    test('can merge rules', async () => {
+        const rule = new Rule().required();
+        const stringRule = Rule.string().min(5);
+        const newRule = rule.merge(stringRule);
+        expect(rule).not.toBe(stringRule);
+        expect(newRule).not.toBe(stringRule);
+        expect(rule).not.toBe(newRule);
+        const result = await newRule.validate('Hei', context);
+        expect(result).toMatchSnapshot();
+    });
+    test('can merge rules', () => {
+        expect(new Rule().required().isRequired()).toBe(true);
+        expect(new Rule().isRequired()).toBe(false);
+        expect(new Rule().optional().isRequired()).toBe(false);
+    });
+});
+//# sourceMappingURL=generics.test.js.map

package/lib/dts/test/infer.test.d.ts

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