@sprucelabs/schema 25.5.63 → 25.5.67

package/build/esm/__tests__/implementation/FileField.test.d.ts

@@ -1,19 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import { FileFieldValue } from '../../fields/FileField.types';
-interface FileDetailExpectations {
-    expectedName: string;
-    expectedType: string;
-    expectedExtension: string;
-}
-declare enum EnvKind {
-    Linux = "linux",
-    Windows = "windows"
-}
-export default class FileFieldTest extends AbstractSpruceTest {
-    private static fileDefinition;
-    static testGettingFileDetails(filePath: string, expectations: FileDetailExpectations): void;
-    static testCompletingFileObject(partial: Partial<FileFieldValue>, complete: FileFieldValue): void;
-    static testInSchema(env: EnvKind, expectedPath: string, setTarget: FileFieldValue): void;
-    protected static testGettingRelativePath(path: string, relativeTo: string, expectedPath: string): void;
-}
-export {};

package/build/esm/__tests__/implementation/FileField.test.js

@@ -1,125 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import path from 'path';
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
-import FieldFactory from '../../factories/FieldFactory.js';
-import StaticSchemaEntityImplementation from '../../StaticSchemaEntityImplementation.js';
-import buildSchema from '../../utilities/buildSchema.js';
-var EnvKind;
-(function (EnvKind) {
-    EnvKind["Linux"] = "linux";
-    EnvKind["Windows"] = "windows";
-})(EnvKind || (EnvKind = {}));
-const linuxTestPath = '/some/directory/path';
-const windowsTestPath = 'C:\\some\\directory\\path';
-export default class FileFieldTest extends AbstractSpruceTest {
-    static testGettingFileDetails(filePath, expectations) {
-        const field = FieldFactory.Field('test', {
-            type: 'file',
-        });
-        const file = field.toValueType(filePath);
-        assert.isEqual(file.name, expectations.expectedName, 'File name did not parse as expected');
-        assert.isEqual(file.type, expectations.expectedType, 'File type did not lookup as expected');
-        assert.isEqual(file.ext, expectations.expectedExtension, 'File type did not lookup as expected');
-    }
-    static testCompletingFileObject(partial, complete) {
-        const file = FieldFactory.Field('test', { type: 'file' });
-        const augmented = file.toValueType(partial);
-        assert.isEqualDeep(augmented, complete);
-    }
-    static testInSchema(env, expectedPath, setTarget) {
-        if (env === EnvKind.Linux) {
-            // @ts-ignore
-            path.sep = '/';
-        }
-        else if (env === EnvKind.Windows) {
-            // @ts-ignore
-            path.sep = '\\';
-        }
-        const schema = new StaticSchemaEntityImplementation(this.fileDefinition);
-        schema.set('target', setTarget);
-        const values = schema.getValues({
-            fields: ['target'],
-        });
-        assert.isTruthy(values.target);
-        assert.isEqual(values.target.path, expectedPath);
-    }
-    static testGettingRelativePath(path, relativeTo, expectedPath) {
-        const schema = new StaticSchemaEntityImplementation(this.fileDefinition);
-        schema.set('target', { path, name: 'app.ts' });
-        const target = schema.get('target', { byField: { target: { relativeTo } } });
-        assert.isEqual(target.path, expectedPath);
-    }
-}
-FileFieldTest.fileDefinition = buildSchema({
-    id: 'testFeature',
-    name: 'Test Feature',
-    fields: {
-        target: {
-            type: 'file',
-            isRequired: true,
-            label: 'What file would you like to test?',
-        },
-    },
-});
-__decorate([
-    test('Can get .ts details', '/does/not/need/to/exist/TestFile.ts', {
-        expectedName: 'TestFile.ts',
-        expectedType: 'application/typescript',
-        expectedExtension: '.ts',
-    }),
-    test('Can get .js details', '/does/not/need/to/exist/TestFile.js', {
-        expectedName: 'TestFile.js',
-        expectedType: 'application/javascript',
-        expectedExtension: '.js',
-    }),
-    test('Can get .png details', '/does/not/need/to/exist/avatar.png', {
-        expectedName: 'avatar.png',
-        expectedType: 'image/png',
-        expectedExtension: '.png',
-    })
-], FileFieldTest, "testGettingFileDetails", null);
-__decorate([
-    test('Can get file value based on only name', { name: 'NewFile.ts' }, {
-        name: 'NewFile.ts',
-        ext: '.ts',
-        type: 'application/typescript',
-        path: undefined,
-    }),
-    test('Can get file value based on only path', { path: '/path/to/a/non/existent/file/isTruthy/NewFile.ts' }, {
-        name: 'NewFile.ts',
-        ext: '.ts',
-        type: 'application/typescript',
-        path: '/path/to/a/non/existent/file/isTruthy',
-    })
-], FileFieldTest, "testCompletingFileObject", null);
-__decorate([
-    test('Can create schema and properly parse path set path', EnvKind.Linux, linuxTestPath, {
-        path: linuxTestPath,
-        ext: '.ts',
-        type: 'application/typescript',
-        name: 'test.ts',
-    }),
-    test('Can create schema and properly parse path set path by name', EnvKind.Linux, linuxTestPath, {
-        name: `${linuxTestPath}/test.ts`,
-    }),
-    test('Can create schema and properly parse path set as string', EnvKind.Linux, linuxTestPath, `${linuxTestPath}/test.ts`),
-    test('Can create schema and properly parse path set path in windows', EnvKind.Windows, windowsTestPath, {
-        path: windowsTestPath,
-        ext: '.ts',
-        type: 'application/typescript',
-        name: 'test.ts',
-    }),
-    test('Can create schema and properly parse path set path by name in windows', EnvKind.Windows, windowsTestPath, {
-        name: `${windowsTestPath}\\test.ts`,
-    }),
-    test('Can create schema and properly parse path set as string in windows', EnvKind.Windows, windowsTestPath, `${windowsTestPath}/test.ts`)
-], FileFieldTest, "testInSchema", null);
-__decorate([
-    test('can get paths relative to provided relativeTo', '/home/user/test/me', '/home/user', 'test/me'),
-    test('can get paths relative to provided relativeTo going back', '/home/user/test/me', '/home/user/tacos', '../test/me')
-], FileFieldTest, "testGettingRelativePath", null);

package/build/esm/__tests__/implementation/NumberField.test.d.ts

@@ -1,5 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class NumberFieldTest extends AbstractSchemaTest {
-    protected static numberFieldErrorsWhenValueNaN(input: string, shouldPass: boolean): Promise<void>;
-    protected static convertsThingsToNumbers(input: any, expected: number): Promise<void>;
-}

package/build/esm/__tests__/implementation/NumberField.test.js

@@ -1,54 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import FieldFactory from '../../factories/FieldFactory.js';
-export default class NumberFieldTest extends AbstractSchemaTest {
-    static numberFieldErrorsWhenValueNaN(input, shouldPass) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const field = FieldFactory.Field('test', {
-                type: 'number',
-            });
-            const errs = field.validate(input);
-            if (shouldPass) {
-                assert.isEqual(errs.length, 0);
-            }
-            else {
-                assert.isAbove(errs.length, 0);
-                assert.doesInclude(errs[0], { code: 'INVALID_PARAMETER' });
-            }
-        });
-    }
-    static convertsThingsToNumbers(input, expected) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const field = FieldFactory.Field('test', {
-                type: 'number',
-            });
-            const actual = field.toValueType(input);
-            assert.isEqual(actual, expected);
-        });
-    }
-}
-__decorate([
-    test('non-string characters fails', 'aoeuaoeu', false),
-    test('number passes', 4, true),
-    test('string as number passes', '4', true),
-    test('null passes when not required', null, true),
-    test('undefined passes when not required', undefined, true)
-], NumberFieldTest, "numberFieldErrorsWhenValueNaN", null);
-__decorate([
-    test('string number transformed to number', '4', 4)
-], NumberFieldTest, "convertsThingsToNumbers", null);

package/build/esm/__tests__/implementation/PhoneField.test.d.ts

@@ -1,7 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-export declare class PhoneFieldTest extends AbstractSpruceTest {
-    protected static validate(phone: string, expected: any, isRequired?: boolean): void;
-    protected static format(phone: string, expected: string): void;
-    protected static failingFormattingWithFailSilentReturnsOriginalNumber(): void;
-    protected static failSilentlyFalseThrows(): void;
-}

package/build/esm/__tests__/implementation/PhoneField.test.js

@@ -1,82 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import AbstractSpruceTest, { assert, test } from '@sprucelabs/test';
-import FieldFactory from '../../factories/FieldFactory.js';
-import formatPhoneNumber from '../../utilities/formatPhoneNumber.js';
-export class PhoneFieldTest extends AbstractSpruceTest {
-    static validate(phone, expected, isRequired = false) {
-        const field = FieldFactory.Field('phone', {
-            type: 'phone',
-            isRequired,
-        });
-        const errors = field.validate(phone);
-        assert.doesInclude(errors, expected);
-    }
-    static format(phone, expected) {
-        const field = FieldFactory.Field('phone', {
-            type: 'phone',
-        });
-        const actual = field.toValueType(phone);
-        assert.isEqual(actual, expected);
-    }
-    static failingFormattingWithFailSilentReturnsOriginalNumber() {
-        const formatted = formatPhoneNumber('aoeuaoue', true);
-        assert.isEqual(formatted, 'aoeuaoue');
-    }
-    static failSilentlyFalseThrows() {
-        const err = assert.doesThrow(() => formatPhoneNumber('aoeuaoue', false));
-        assert.isTruthy(err);
-        assert.isTruthy(err.message, 'INVALID_PHONE_NUMBER');
-    }
-}
-__decorate([
-    test('can handle dummy number', '1-555-555-5555', []),
-    test('optional handles null phone', null, []),
-    test('optional handles undefined phone', undefined, []),
-    test('can handle dummy number without country code', '555-555-5555', []),
-    test('can handle dummy number with country code +', '+1 555-555-5555', []),
-    test('can handle dummy number with country code and hyphen', '+1-555-555-5555', []),
-    test('fails with bad number', '234th2s34th', [
-        {
-            code: 'INVALID_PARAMETER',
-            name: 'phone',
-        },
-    ]),
-    test('fails with partial number', '720253', [
-        {
-            code: 'INVALID_PARAMETER',
-            name: 'phone',
-        },
-    ]),
-    test('fails with bad number with country', '+1 234th2s34th', [
-        {
-            code: 'INVALID_PARAMETER',
-            name: 'phone',
-        },
-    ]),
-    test('required fails with empty string for a number', '', [{ code: 'MISSING_PARAMETER', name: 'phone' }], true),
-    test('passes with good number', '720-253-5555', []),
-    test('passes with good number with country', '+1720-253-5555', []),
-    test('passes with good number with country formatted', '+1 720-253-5555', []),
-    test('passes with good number with country formatted hyphen', '+1-720-253-5555', [])
-], PhoneFieldTest, "validate", null);
-__decorate([
-    test('formats 720', '720', '+1 720'),
-    test('formats 720233', '720233', '+1 720-233'),
-    test('formats 72023323', '72023323', '+1 720-233-23'),
-    test('formats 720-233-2355', '720-233-2355', '+1 720-233-2355'),
-    test('formats 7202332355', '7202332355', '+1 720-233-2355'),
-    test('formats 720 233 2355', '720 233 2355', '+1 720-233-2355'),
-    test('formats 1720 233 2355', '1720 233 2355', '+1 720-233-2355'),
-    test('formats +1-720-233-2355', '+1-720-233-2355', '+1 720-233-2355')
-], PhoneFieldTest, "format", null);
-__decorate([
-    test()
-], PhoneFieldTest, "failingFormattingWithFailSilentReturnsOriginalNumber", null);
-__decorate([
-    test()
-], PhoneFieldTest, "failSilentlyFalseThrows", null);

package/build/esm/__tests__/implementation/SchemaFieldTransformingOptions.test.d.ts

@@ -1,5 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import { SchemaFieldFieldDefinition } from '../../fields/SchemaField.types';
-export default class SchemaFieldTemplateTest extends AbstractSpruceTest {
-    protected static testNormalizingOptionsToId(options: SchemaFieldFieldDefinition['options'], toSchemaIdExpected: any, toSchemaOrIdExpected?: any): Promise<void>;
-}

package/build/esm/__tests__/implementation/SchemaFieldTransformingOptions.test.js

@@ -1,209 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
-import SchemaField from '../../fields/SchemaField.js';
-import buildSchema from '../../utilities/buildSchema.js';
-const wrenchSchema = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-const versionedWrench = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    version: '1.0',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-const namespacedWrench = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    namespace: 'one',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-const namespacedVersionedWrench = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    version: '1.0',
-    namespace: 'one',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-const namespaced2VersionedWrench = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    version: '1.0',
-    namespace: 'two',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-const screwdriverSchema = buildSchema({
-    id: 'screwdriver',
-    name: 'Screwdriver',
-    fields: {
-        isFlathead: {
-            type: 'boolean',
-        },
-        screwdriverLength: {
-            type: 'number',
-            label: 'Length',
-        },
-    },
-});
-const personSchema = buildSchema({
-    id: 'union-person',
-    name: 'Union Person',
-    fields: {
-        favoriteTool: {
-            type: 'schema',
-            options: {
-                schemas: [wrenchSchema, screwdriverSchema],
-            },
-        },
-        tools: {
-            type: 'schema',
-            isArray: true,
-            options: {
-                schemas: [wrenchSchema, screwdriverSchema],
-            },
-        },
-    },
-});
-export default class SchemaFieldTemplateTest extends AbstractSpruceTest {
-    static testNormalizingOptionsToId(options, toSchemaIdExpected, toSchemaOrIdExpected) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const idsWithVersion = SchemaField.mapFieldDefinitionToSchemaIdsWithVersion({
-                type: 'schema',
-                options,
-            });
-            assert.isEqualDeep(idsWithVersion, toSchemaIdExpected);
-            const schemasOrIdsWithVersion = SchemaField.mapFieldDefinitionToSchemasOrIdsWithVersion({
-                type: 'schema',
-                options,
-            });
-            assert.isEqualDeep(schemasOrIdsWithVersion, toSchemaOrIdExpected !== null && toSchemaOrIdExpected !== void 0 ? toSchemaOrIdExpected : toSchemaIdExpected);
-        });
-    }
-}
-__decorate([
-    test('can normalize schemaId to array [schemaId]', { schemaId: 'user' }, [
-        { id: 'user' },
-    ]),
-    test('can normalize schemaIds to array [schemaId]', { schemaIds: ['user', 'wrench'] }, [{ id: 'user' }, { id: 'wrench' }]),
-    test('can normalize schemaIds to array [schemaId]', { schemaIds: ['user', 'wrench'] }, [{ id: 'user' }, { id: 'wrench' }]),
-    test('can normalize schema to array [schemaId]', { schema: wrenchSchema }, [{ id: 'wrench' }], [wrenchSchema]),
-    test('can normalize schemas to array [schemaId]', {
-        schemas: [wrenchSchema, screwdriverSchema],
-    }, [{ id: 'wrench' }, { id: 'screwdriver' }], [wrenchSchema, screwdriverSchema]),
-    test('can normalize schema, schemas to array [schemaId]', {
-        schema: personSchema,
-        schemas: [wrenchSchema, screwdriverSchema],
-    }, [{ id: 'union-person' }, { id: 'wrench' }, { id: 'screwdriver' }], [personSchema, wrenchSchema, screwdriverSchema]),
-    test('can normalize schemas, schema to array [schemaId]', {
-        schemas: [wrenchSchema, screwdriverSchema],
-        schema: personSchema,
-    }, [{ id: 'union-person' }, { id: 'wrench' }, { id: 'screwdriver' }], [personSchema, wrenchSchema, screwdriverSchema]),
-    test('can normalize schemas, schemaId to array [schemaId]', {
-        schemas: [wrenchSchema, screwdriverSchema],
-        schemaId: 'union-person',
-    }, [{ id: 'union-person' }, { id: 'wrench' }, { id: 'screwdriver' }], [{ id: 'union-person' }, wrenchSchema, screwdriverSchema]),
-    test('can handle versioned and un-versioned', {
-        schemas: [
-            {
-                id: versionedWrench.id,
-                version: versionedWrench.version,
-            },
-            wrenchSchema,
-        ],
-    }, [
-        { id: versionedWrench.id, version: versionedWrench.version },
-        { id: wrenchSchema.id },
-    ], [{ id: versionedWrench.id, version: versionedWrench.version }, wrenchSchema]),
-    test('can handle same namespace with different versions', {
-        schemas: [
-            {
-                id: namespacedVersionedWrench.id,
-                version: namespacedVersionedWrench.version,
-                namespace: namespacedVersionedWrench.namespace,
-            },
-            namespacedWrench,
-        ],
-    }, [
-        {
-            id: namespacedVersionedWrench.id,
-            version: namespacedVersionedWrench.version,
-            namespace: namespacedVersionedWrench.namespace,
-        },
-        { id: namespacedWrench.id, namespace: namespacedWrench.namespace },
-    ], [
-        {
-            id: namespacedVersionedWrench.id,
-            version: namespacedVersionedWrench.version,
-            namespace: namespacedVersionedWrench.namespace,
-        },
-        namespacedWrench,
-    ]),
-    test('can handle different namespace with same versions and and id', {
-        schemas: [
-            {
-                id: namespacedVersionedWrench.id,
-                version: namespacedVersionedWrench.version,
-                namespace: namespacedVersionedWrench.namespace,
-            },
-            namespaced2VersionedWrench,
-        ],
-    }, [
-        {
-            id: namespacedVersionedWrench.id,
-            version: namespacedVersionedWrench.version,
-            namespace: namespacedVersionedWrench.namespace,
-        },
-        {
-            id: namespaced2VersionedWrench.id,
-            version: namespaced2VersionedWrench.version,
-            namespace: namespaced2VersionedWrench.namespace,
-        },
-    ], [
-        {
-            id: namespacedVersionedWrench.id,
-            version: namespacedVersionedWrench.version,
-            namespace: namespacedVersionedWrench.namespace,
-        },
-        namespaced2VersionedWrench,
-    ])
-], SchemaFieldTemplateTest, "testNormalizingOptionsToId", null);

package/build/esm/__tests__/implementation/SchemaFieldValidation.test.d.ts

@@ -1,8 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class SchemaFieldTest extends AbstractSchemaTest {
-    private static personSchema;
-    protected static beforeEach(): Promise<void>;
-    protected static testNonUnionValidation(value: any, expectedErrorCodes: string[]): Promise<void>;
-    protected static testSingleUnionFailsValidation(): Promise<void>;
-    protected static testSingleUnionValidation(): Promise<void>;
-}

package/build/esm/__tests__/implementation/SchemaFieldValidation.test.js

@@ -1,87 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import FieldFactory from '../../factories/FieldFactory.js';
-import buildPersonWithCar from '../data/personWithCars.js';
-export default class SchemaFieldTest extends AbstractSchemaTest {
-    static beforeEach() {
-        const _super = Object.create(null, {
-            beforeEach: { get: () => super.beforeEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.beforeEach.call(this);
-            const { personSchema } = buildPersonWithCar();
-            this.personSchema = personSchema;
-        });
-    }
-    static testNonUnionValidation(value, expectedErrorCodes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requiredField = FieldFactory.Field('requiredCar', this.personSchema.fields.requiredCar);
-            const optionalField = FieldFactory.Field('optionalCar', this.personSchema.fields.optionalCar);
-            const requiredIsArrayField = FieldFactory.Field('requiredIsArrayCar', this.personSchema.fields.requiredIsArrayCars);
-            const optionalIsArrayField = FieldFactory.Field('optionalRequiredCar', this.personSchema.fields.optionalIsArrayCars);
-            let codes = requiredField.validate(value).map((err) => err.code);
-            assert.isEqualDeep(codes, expectedErrorCodes);
-            codes = optionalField.validate(value).map((err) => err.code);
-            assert.isEqualDeep(codes, expectedErrorCodes);
-            codes = requiredIsArrayField.validate(value).map((err) => err.code);
-            assert.isEqualDeep(codes, expectedErrorCodes);
-            codes = optionalIsArrayField.validate(value).map((err) => err.code);
-            assert.isEqualDeep(codes, expectedErrorCodes);
-        });
-    }
-    static testSingleUnionFailsValidation() {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const optionalCarOrTruckField = FieldFactory.Field('optionalCarOrTruck', this.personSchema.fields.optionalCarOrTruck);
-            const value = {
-                schemaId: 'car',
-                values: {},
-            };
-            const errors = optionalCarOrTruckField.validate(value);
-            assert.isEqual(errors[0].code, 'INVALID_PARAMETER');
-            assert.isEqual((_b = (_a = errors[0].errors) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code, 'MISSING_PARAMETER');
-            assert.isEqual((_d = (_c = errors[0].errors) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.name, 'name');
-        });
-    }
-    static testSingleUnionValidation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const optionalCarOrTruckField = FieldFactory.Field('optionalCarOrTruck', this.personSchema.fields.optionalCarOrTruck);
-            const value = {
-                schemaId: 'car',
-                values: {
-                    name: 'great car',
-                },
-            };
-            const codes = optionalCarOrTruckField.validate(value);
-            assert.isLength(codes, 0);
-        });
-    }
-}
-__decorate([
-    test('fails on non-object', true, ['INVALID_PARAMETER']),
-    test('passes because everything has name and a string is good', { name: 'cheese!' }, []),
-    test("knows it's missing the name and name is required", { taco: true }, [
-        'INVALID_PARAMETER',
-    ])
-], SchemaFieldTest, "testNonUnionValidation", null);
-__decorate([
-    test()
-], SchemaFieldTest, "testSingleUnionFailsValidation", null);
-__decorate([
-    test()
-], SchemaFieldTest, "testSingleUnionValidation", null);

package/build/esm/__tests__/implementation/SelectField.test.d.ts

@@ -1,8 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-export default class SelectFieldTest extends AbstractSpruceTest {
-    private static userSchema;
-    protected static canMakeSelectOptionsUnion(): Promise<void>;
-    protected static catchesBadChoice(): void;
-    protected static validationHandlesUndefinedForOptional(): void;
-    protected static validationHandlesRequired(): void;
-}