@sprucelabs/schema 25.5.65 → 25.5.69

package/build/esm/__tests__/behavioral/NormalizeToSchemaIdWithVersion.test.js

@@ -1,77 +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 normalizeSchemaToIdWithVersion from '../../utilities/normalizeSchemaToIdWithVersion.js';
-export default class NormalizeToSchemaIdWithVersionTest extends AbstractSchemaTest {
-    static functionExists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isFunction(normalizeSchemaToIdWithVersion);
-        });
-    }
-    static testNormalizing(schemaOrIdWithVersion, expected) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const actual = normalizeSchemaToIdWithVersion(schemaOrIdWithVersion);
-            assert.isEqualDeep(actual, expected);
-        });
-    }
-}
-__decorate([
-    test()
-], NormalizeToSchemaIdWithVersionTest, "functionExists", null);
-__decorate([
-    test('does nothing to idWithVersion', {
-        id: 'test',
-    }, {
-        id: 'test',
-    }),
-    test('converts schema to idWithVersion', {
-        id: 'test',
-        fields: {
-            textfield: {
-                type: 'text',
-            },
-        },
-    }, {
-        id: 'test',
-    }),
-    test('maintains version', {
-        id: 'test',
-        version: '1.0',
-        fields: {
-            textfield: {
-                type: 'text',
-            },
-        },
-    }, {
-        id: 'test',
-        version: '1.0',
-    }),
-    test('maintains namespace and version', {
-        id: 'test',
-        version: '1.0',
-        namespace: 'test',
-        fields: {
-            textfield: {
-                type: 'text',
-            },
-        },
-    }, {
-        id: 'test',
-        namespace: 'test',
-        version: '1.0',
-    })
-], NormalizeToSchemaIdWithVersionTest, "testNormalizing", null);

package/build/esm/__tests__/behavioral/NormalizingSchemaValues.test.d.ts

@@ -1,8 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class NormalizingSchemaValues extends AbstractSchemaTest {
-    private static personSchema;
-    protected static normalizesSimpleAsExpected(): void;
-    protected static normalizeTypesAsExpected(): void;
-    protected static normalizeAndCheckField(overrideValues: Record<string, any>, fieldName: string, expected: any): void;
-    protected static honorsNotMakingSchemaEntitiesWithEntityValues(): void;
-}

package/build/esm/__tests__/behavioral/NormalizingSchemaValues.test.js

@@ -1,148 +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 { test, assert } from '@sprucelabs/test';
-import StaticSchemaEntityImplementation from '../../index.js';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import normalizeSchemaValues from '../../utilities/normalizeSchemaValues.js';
-export default class NormalizingSchemaValues extends AbstractSchemaTest {
-    static normalizesSimpleAsExpected() {
-        const values = normalizeSchemaValues(this.personSchema, {
-            // @ts-ignore
-            firstName: 12345,
-            // @ts-ignore
-            age: '10',
-            nestedArraySchema: [{ field1: 'first' }, { field1: 'second' }],
-        }, { shouldCreateEntityInstances: false });
-        assert.isEqualDeep(values, {
-            firstName: '12345',
-            age: 10,
-            boolean: undefined,
-            privateBooleanField: undefined,
-            nestedArraySchema: [{ field1: 'first' }, { field1: 'second' }],
-        });
-    }
-    static normalizeTypesAsExpected() {
-        const values = normalizeSchemaValues(this.personSchema, {
-            firstName: 'tay',
-            age: 0,
-            nestedArraySchema: [{ field1: 'first' }, { field1: 'second' }],
-        }, { shouldCreateEntityInstances: false });
-        assert.isExactType(true);
-    }
-    static normalizeAndCheckField(overrideValues, fieldName, expected) {
-        const values = normalizeSchemaValues(this.personSchema, Object.assign({ firstName: 'tay', age: 0, nestedArraySchema: [{ field1: 'first' }, { field1: 'second' }] }, overrideValues));
-        //@ts-ignore
-        assert.isEqual(values[fieldName], expected);
-    }
-    static honorsNotMakingSchemaEntitiesWithEntityValues() {
-        const secondLevelSchema = buildSchema({
-            id: 'nested-2nd-level-schema-entity',
-            fields: {
-                boolField: {
-                    type: 'boolean',
-                },
-            },
-        });
-        const schema = buildSchema({
-            id: 'schema-entities',
-            fields: {
-                related: {
-                    type: 'schema',
-                    isArray: true,
-                    isRequired: true,
-                    options: {
-                        schema: {
-                            id: 'nested-schema-entities',
-                            fields: {
-                                textField: {
-                                    type: 'text',
-                                },
-                                nested: {
-                                    type: 'schema',
-                                    options: {
-                                        schema: secondLevelSchema,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        const values = normalizeSchemaValues(schema, {
-            related: [
-                {
-                    textField: 'hello!',
-                    nested: new StaticSchemaEntityImplementation(secondLevelSchema, {
-                        boolField: true,
-                    }),
-                },
-            ],
-        }, { shouldCreateEntityInstances: false });
-        assert.isFalse(values.related[0] instanceof StaticSchemaEntityImplementation);
-        assert.isFalse(values.related[0].nested instanceof StaticSchemaEntityImplementation);
-        assert.isEqualDeep(values, {
-            related: [
-                {
-                    textField: 'hello!',
-                    nested: { boolField: true },
-                },
-            ],
-        });
-    }
-}
-NormalizingSchemaValues.personSchema = buildSchema({
-    id: 'testPerson',
-    name: 'A test person',
-    fields: {
-        firstName: {
-            type: 'text',
-            isRequired: true,
-        },
-        age: {
-            type: 'number',
-        },
-        boolean: {
-            type: 'boolean',
-        },
-        privateBooleanField: {
-            type: 'boolean',
-            isPrivate: true,
-        },
-        nestedArraySchema: {
-            type: 'schema',
-            isArray: true,
-            options: {
-                schema: {
-                    id: 'nested-schema',
-                    name: 'Nested',
-                    fields: {
-                        field1: {
-                            type: 'text',
-                        },
-                    },
-                },
-            },
-        },
-    },
-});
-__decorate([
-    test()
-], NormalizingSchemaValues, "normalizesSimpleAsExpected", null);
-__decorate([
-    test()
-], NormalizingSchemaValues, "normalizeTypesAsExpected", null);
-__decorate([
-    test('normalizes boolean with string false to false', { boolean: 'false' }, 'boolean', false),
-    test('normalizes boolean with string true to true', { boolean: 'true' }, 'boolean', true),
-    test('normalizes private boolean with string false to false', { privateBooleanField: 'false' }, 'privateBooleanField', false),
-    test('normalizes private boolean with string true to true', { privateBooleanField: 'true' }, 'privateBooleanField', true)
-], NormalizingSchemaValues, "normalizeAndCheckField", null);
-__decorate([
-    test()
-], NormalizingSchemaValues, "honorsNotMakingSchemaEntitiesWithEntityValues", null);

package/build/esm/__tests__/behavioral/ResetsSchemasEveryTest.test.d.ts

@@ -1,6 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class ResetsSchemasEveryTest extends AbstractSchemaTest {
-    protected static beforeEach(): Promise<void>;
-    protected static importPersonWithCar(): void;
-    protected static importPersonWithCarASecondTime(): void;
-}

package/build/esm/__tests__/behavioral/ResetsSchemasEveryTest.test.js

@@ -1,45 +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 { assert, test } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import buildPersonWithCars from '../data/personWithCars.js';
-export default class ResetsSchemasEveryTest 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);
-            assert.isEqual(this.registry.getTrackingCount(), 0);
-        });
-    }
-    static importPersonWithCar() {
-        assert.isEqual(this.registry.getTrackingCount(), 0);
-        buildPersonWithCars();
-        assert.isEqual(this.registry.getTrackingCount(), 3);
-    }
-    static importPersonWithCarASecondTime() {
-        assert.isEqual(this.registry.getTrackingCount(), 0);
-        buildPersonWithCars();
-        assert.isEqual(this.registry.getTrackingCount(), 3);
-    }
-}
-__decorate([
-    test()
-], ResetsSchemasEveryTest, "importPersonWithCar", null);
-__decorate([
-    test()
-], ResetsSchemasEveryTest, "importPersonWithCarASecondTime", null);

package/build/esm/__tests__/behavioral/SchemaDefaultValues.test.d.ts

@@ -1,9 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import { Schema } from '../../schemas.static.types';
-export default class SchemaDefaultValuesTest extends AbstractSpruceTest {
-    protected static textAndSelectDefaultValues(): void;
-    protected static defaultValueTests(definition: Schema, expectedDefaultValues: Record<string, any>): void;
-    protected static defaultValueTypeTests(): void;
-    protected static canGetDefaultValuesFromSchemaWithRequiredFields(): void;
-    protected static canGetDefaultValuesForUnionFields(): void;
-}

package/build/esm/__tests__/behavioral/SchemaDefaultValues.test.js

@@ -1,138 +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, { test, assert } from '@sprucelabs/test';
-import StaticSchemaEntityImplementation from '../../StaticSchemaEntityImplementation.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import defaultSchemaValues from '../../utilities/defaultSchemaValues.js';
-import buildPersonWithCars from '../data/personWithCars.js';
-StaticSchemaEntityImplementation.enableDuplicateCheckWhenTracking = false;
-// we don't need these registered
-const { personSchema, carSchema } = buildPersonWithCars();
-export default class SchemaDefaultValuesTest extends AbstractSpruceTest {
-    static textAndSelectDefaultValues() {
-        let fieldName;
-        // make sure types are 100% (only works if they are currently undefined)
-        assert.isType(fieldName);
-    }
-    static defaultValueTests(definition, expectedDefaultValues) {
-        const schema = new StaticSchemaEntityImplementation(definition);
-        const defaultValues = schema.getDefaultValues();
-        assert.isEqualDeep(defaultValues, expectedDefaultValues);
-    }
-    static defaultValueTypeTests() {
-        const schema = new StaticSchemaEntityImplementation(personSchema);
-        const defaultValues = schema.getDefaultValues();
-        const defaultValuesWithoutSchemas = schema.getDefaultValues({
-            shouldCreateEntityInstances: false,
-        });
-        assert.isFunction(defaultValues.optionalIsArrayCarOrTruckWithDefaultValue[0].get);
-        assert.isEqual(defaultValuesWithoutSchemas.optionalIsArrayCarOrTruckWithDefaultValue[0]
-            .schemaId, 'car');
-        assert.isEqual(defaultValuesWithoutSchemas.optionalIsArrayCarOrTruckWithDefaultValue[0]
-            .values.name, 'fast car');
-        const carEntity = new StaticSchemaEntityImplementation(carSchema, {
-            name: 'fast car',
-        });
-        assert.isType(defaultValues);
-        assert.isEqualDeep(defaultValues.optionalIsArrayCarOrTruckWithDefaultValue, [carEntity]);
-        assert.isType(defaultValuesWithoutSchemas);
-        assert.isType(defaultValues);
-    }
-    static canGetDefaultValuesFromSchemaWithRequiredFields() {
-        const avatar = buildSchema({
-            id: 'sprucebotAvatar',
-            name: 'Sprucebot avatar',
-            description: '',
-            fields: {
-                size: {
-                    type: 'select',
-                    label: 'Size',
-                    isRequired: true,
-                    defaultValue: 'medium',
-                    options: {
-                        choices: [
-                            {
-                                value: 'small',
-                                label: 'Small',
-                            },
-                            {
-                                value: 'medium',
-                                label: 'Medium',
-                            },
-                            {
-                                value: 'large',
-                                label: 'Large',
-                            },
-                        ],
-                    },
-                },
-                stateOfMind: {
-                    type: 'select',
-                    label: 'State of mind',
-                    isRequired: true,
-                    defaultValue: 'chill',
-                    options: {
-                        choices: [
-                            {
-                                value: 'chill',
-                                label: 'Chill - Sprucebot is saying something informative or a salutation',
-                            },
-                            {
-                                value: 'contemplative',
-                                label: 'Contemplative - Sprucebot is loading or sending data',
-                            },
-                            {
-                                value: 'accomplished',
-                                label: 'Accomplished - Sprucebot is celebrating because a process has finished',
-                            },
-                        ],
-                    },
-                },
-            },
-        });
-        const defaults = defaultSchemaValues(avatar);
-        assert.isEqualDeep(defaults, { size: 'medium', stateOfMind: 'chill' });
-    }
-    static canGetDefaultValuesForUnionFields() {
-        const schema = new StaticSchemaEntityImplementation(personSchema);
-        const { optionalIsArrayCarOrTruckWithDefaultValue, optionalCarOrTruckWithDefaultValue, } = schema.getDefaultValues();
-        assert.isFunction(optionalCarOrTruckWithDefaultValue.get);
-        assert.isEqual(optionalIsArrayCarOrTruckWithDefaultValue.length, 1, '');
-        assert.isEqual(optionalCarOrTruckWithDefaultValue.schemaId === 'car' &&
-            optionalCarOrTruckWithDefaultValue.get('name'), 'fast car');
-        assert.isEqual(optionalIsArrayCarOrTruckWithDefaultValue[0] &&
-            optionalIsArrayCarOrTruckWithDefaultValue[0].schemaId === 'car' &&
-            optionalIsArrayCarOrTruckWithDefaultValue[0].get('name'), 'fast car');
-    }
-}
-__decorate([
-    test('Test typing on default values (test will always pass, lint will fail)')
-], SchemaDefaultValuesTest, "textAndSelectDefaultValues", null);
-__decorate([
-    test('Gets default values while creating schema instances', personSchema, {
-        optionalCarWithDefaultValue: new StaticSchemaEntityImplementation(carSchema, {
-            name: 'fast car',
-        }),
-        optionalSelectWithDefaultValue: 'hello',
-        optionalTextWithDefaultValue: 'world',
-        optionalIsArrayCarOrTruckWithDefaultValue: [
-            new StaticSchemaEntityImplementation(carSchema, { name: 'fast car' }),
-        ],
-        optionalCarOrTruckWithDefaultValue: new StaticSchemaEntityImplementation(carSchema, {
-            name: 'fast car',
-        }),
-    })
-], SchemaDefaultValuesTest, "defaultValueTests", null);
-__decorate([
-    test('Can get default typed correctly (test will pass, lint will fail)')
-], SchemaDefaultValuesTest, "defaultValueTypeTests", null);
-__decorate([
-    test()
-], SchemaDefaultValuesTest, "canGetDefaultValuesFromSchemaWithRequiredFields", null);
-__decorate([
-    test()
-], SchemaDefaultValuesTest, "canGetDefaultValuesForUnionFields", null);

package/build/esm/__tests__/behavioral/SelectChoicesToHash.test.d.ts

@@ -1,4 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-export default class SelectOptionsToHashTest extends AbstractSpruceTest {
-    protected static testCreatingOptionHashes(): Promise<void>;
-}

package/build/esm/__tests__/behavioral/SelectChoicesToHash.test.js

@@ -1,43 +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 { selectChoicesToHash, schemaChoicesToHash, } from '../../utilities/selectChoicesToHash.js';
-import buildPersonWithCars from '../data/personWithCars.js';
-export default class SelectOptionsToHashTest extends AbstractSpruceTest {
-    static testCreatingOptionHashes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { personSchema } = buildPersonWithCars();
-            const options = personSchema.fields.optionalSelect.options.choices;
-            const optionsHash = selectChoicesToHash(options);
-            assert.isType(optionsHash);
-            assert.isType(optionsHash);
-            assert.isEqualDeep(optionsHash, { foo: 'Foo', bar: 'Bar' });
-            const optionsHash2 = schemaChoicesToHash(personSchema, 'optionalSelect');
-            const optionsHash3 = schemaChoicesToHash(personSchema, 'optionalSelectWithDefaultValue');
-            const fieldName = 'optionalSelectWithDefaultValue';
-            const fieldName2 = 'optionalSelect';
-            assert.isType(fieldName);
-            assert.isType(fieldName2);
-            assert.isType(optionsHash2);
-            assert.isEqualDeep(optionsHash2, { foo: 'Foo', bar: 'Bar' });
-            assert.isType(optionsHash3);
-            assert.isEqualDeep(optionsHash3, { hello: 'world', goodbye: 'darling' });
-        });
-    }
-}
-__decorate([
-    test()
-], SelectOptionsToHashTest, "testCreatingOptionHashes", null);

package/build/esm/__tests__/behavioral/SettingMinAndMaxValuesOnArrayFields.test.d.ts

@@ -1,9 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class SettingMinAndMaxValuesOnArrayFieldsTest extends AbstractSchemaTest {
-    protected static defaultsToOneValueRequired(): void;
-    protected static failsWhenMissing(): void;
-    protected static defaultOneValueRequiredPassesWithOneValue(): void;
-    protected static minArrayLengthZero(): void;
-    protected static minArrayLength2ThrowsWithLessThan(): void;
-    protected static passesWithMoreThanMin(): void;
-}

package/build/esm/__tests__/behavioral/SettingMinAndMaxValuesOnArrayFields.test.js

@@ -1,104 +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 { test, assert } from '@sprucelabs/test';
-import { errorAssertUtil } from '@sprucelabs/test-utils';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import validationErrorAssertUtil from '../../tests/validationErrorAssert.utility.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import validateSchemaValues from '../../utilities/validateSchemaValues.js';
-const noMinOrMaxSchema = buildSchema({
-    id: 'noMinOrMax',
-    fields: {
-        favoriteColors: {
-            type: 'text',
-            isArray: true,
-            isRequired: true,
-        },
-    },
-});
-const zeroMinValuesSchema = buildSchema({
-    id: 'zeroMinValues',
-    fields: {
-        favoriteColors: {
-            type: 'text',
-            isArray: true,
-            isRequired: true,
-            minArrayLength: 0,
-        },
-    },
-});
-const twoMinValuesSchema = buildSchema({
-    id: 'twoMinValues',
-    fields: {
-        favoriteColors: {
-            type: 'text',
-            isArray: true,
-            isRequired: true,
-            minArrayLength: 2,
-        },
-    },
-});
-const zeroMinTwoRequiredFields = buildSchema({
-    id: 'zeroMinTwoRequiredFields',
-    fields: {
-        name: {
-            type: 'text',
-            isRequired: true,
-        },
-        favoriteColors: {
-            type: 'text',
-            isArray: true,
-            isRequired: true,
-            minArrayLength: 0,
-        },
-    },
-});
-export default class SettingMinAndMaxValuesOnArrayFieldsTest extends AbstractSchemaTest {
-    static defaultsToOneValueRequired() {
-        const err = assert.doesThrow(() => validateSchemaValues(noMinOrMaxSchema, { favoriteColors: [] }));
-        errorAssertUtil.assertError(err, 'VALIDATION_FAILED');
-    }
-    static failsWhenMissing() {
-        const err = assert.doesThrow(() => validateSchemaValues(zeroMinTwoRequiredFields, {}));
-        validationErrorAssertUtil.assertError(err, {
-            missing: ['name', 'favoriteColors'],
-        });
-    }
-    static defaultOneValueRequiredPassesWithOneValue() {
-        validateSchemaValues(noMinOrMaxSchema, { favoriteColors: ['pink'] });
-    }
-    static minArrayLengthZero() {
-        validateSchemaValues(zeroMinValuesSchema, { favoriteColors: [] });
-    }
-    static minArrayLength2ThrowsWithLessThan() {
-        const err = assert.doesThrow(() => validateSchemaValues(twoMinValuesSchema, { favoriteColors: ['purple'] }));
-        errorAssertUtil.assertError(err, 'VALIDATION_FAILED');
-    }
-    static passesWithMoreThanMin() {
-        validateSchemaValues(twoMinValuesSchema, {
-            favoriteColors: ['pink', 'purple'],
-        });
-    }
-}
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "defaultsToOneValueRequired", null);
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "failsWhenMissing", null);
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "defaultOneValueRequiredPassesWithOneValue", null);
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "minArrayLengthZero", null);
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "minArrayLength2ThrowsWithLessThan", null);
-__decorate([
-    test()
-], SettingMinAndMaxValuesOnArrayFieldsTest, "passesWithMoreThanMin", null);

package/build/esm/__tests__/behavioral/UsingSchemas.test.d.ts

@@ -1,13 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class SchemaTest extends AbstractSchemaTest {
-    protected static testBasicValidation(): Promise<void>;
-    protected static testMissingKeys(fieldToDelete: string, expectedErrors: string[]): Promise<void>;
-    protected static canIsArrayValue(): Promise<void>;
-    protected static getSetArrays(): void;
-    protected static testTransformingValuesToValueTypes(): void;
-    protected static testValuesTypesAgainstObjectLiteral(): void;
-    protected static testFullValuesTypes(): void;
-    protected static testGettingOptionsByField(): void;
-    protected static canCorrectlyTypeSchemaWithOneRequiredField(): void;
-    protected static testGenerics(): void;
-}