@sprucelabs/schema 29.4.60 → 30.0.0

package/build/esm/fields/ImageField.d.ts

@@ -3,7 +3,7 @@ import AbstractField from './AbstractField';
 import { ImageFieldDefinition } from './ImageField.types';
 export default class ImageField extends AbstractField<ImageFieldDefinition> {
     static generateTemplateDetails(options: FieldTemplateDetailOptions<ImageFieldDefinition>): FieldTemplateDetails;
-    static get description(): string;
+    static readonly description = "Images of various sizes!";
     validate(value: any): import("..").FieldError[];
     private getRequiredSizes;
 }

package/build/esm/fields/ImageField.js

@@ -1,15 +1,12 @@
 import AbstractField from './AbstractField.js';
 import { requiredImageSizes } from './ImageField.types.js';
-export default class ImageField extends AbstractField {
+class ImageField extends AbstractField {
     static generateTemplateDetails(options) {
         const { definition, importAs } = options;
         return {
             valueType: `${importAs}.ImageFieldValue${definition.isArray ? '[]' : ''}`,
         };
     }
-    static get description() {
-        return 'Images of various sizes!';
-    }
     validate(value) {
         var _a;
         const errors = super.validate(value);
@@ -42,3 +39,5 @@ export default class ImageField extends AbstractField {
         return sizes;
     }
 }
+ImageField.description = 'Images of various sizes!';
+export default ImageField;

package/build/esm/fields/NumberField.d.ts

@@ -3,7 +3,7 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { NumberFieldDefinition } from './NumberField.types';
 export default class NumberField extends AbstractField<NumberFieldDefinition> {
-    static get description(): string;
+    static readonly description = "Handles all types of numbers with min/max and clamp support";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<NumberFieldDefinition>): FieldTemplateDetails;
     toValueType(value: any): number;
     private buildNaNError;

package/build/esm/fields/NumberField.js

@@ -1,9 +1,6 @@
 import SpruceError from '../errors/SpruceError.js';
 import AbstractField from './AbstractField.js';
-export default class NumberField extends AbstractField {
-    static get description() {
-        return 'Handles all types of numbers with min/max and clamp support';
-    }
+class NumberField extends AbstractField {
     static generateTemplateDetails(options) {
         return {
             valueType: `number${options.definition.isArray ? '[]' : ''}`,
@@ -45,3 +42,5 @@ export default class NumberField extends AbstractField {
         return typeof value === 'undefined' || value === null || !isNaN(value);
     }
 }
+NumberField.description = 'Handles all types of numbers with min/max and clamp support';
+export default NumberField;

package/build/esm/fields/PhoneField.d.ts

@@ -3,7 +3,7 @@ import AbstractField from './AbstractField';
 import { ValidateOptions } from './field.static.types';
 import { PhoneFieldDefinition } from './PhoneField.types';
 export default class PhoneField extends AbstractField<PhoneFieldDefinition> {
-    static get description(): string;
+    static readonly description = "Takes anything close to a phone number and formats it. Also great at validating numbers.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<PhoneFieldDefinition>): FieldTemplateDetails;
     toValueType(value: any): string;
     validate(value: any, options?: ValidateOptions<PhoneFieldDefinition>): import("..").FieldError[];

package/build/esm/fields/PhoneField.js

@@ -1,9 +1,6 @@
 import formatPhoneNumber, { isValidNumber, } from '../utilities/formatPhoneNumber.js';
 import AbstractField from './AbstractField.js';
-export default class PhoneField extends AbstractField {
-    static get description() {
-        return 'Takes anything close to a phone number and formats it. Also great at validating numbers.';
-    }
+class PhoneField extends AbstractField {
     static generateTemplateDetails(options) {
         return {
             valueType: `string${options.definition.isArray ? '[]' : ''}`,
@@ -34,3 +31,5 @@ export default class PhoneField extends AbstractField {
         return errors;
     }
 }
+PhoneField.description = 'Takes anything close to a phone number and formats it. Also great at validating numbers.';
+export default PhoneField;

package/build/esm/fields/RawField.d.ts

@@ -2,6 +2,6 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { RawFieldDefinition } from './RawField.types';
 export default class RawField extends AbstractField<RawFieldDefinition> {
-    static get description(): string;
+    static readonly description = "Set an interface directly.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<RawFieldDefinition>): FieldTemplateDetails;
 }

package/build/esm/fields/RawField.js

@@ -1,11 +1,10 @@
 import AbstractField from './AbstractField.js';
-export default class RawField extends AbstractField {
-    static get description() {
-        return 'Set an interface directly.';
-    }
+class RawField extends AbstractField {
     static generateTemplateDetails(options) {
         return {
             valueType: `(${options.definition.options.valueType})${options.definition.isArray ? '[]' : ''}`,
         };
     }
 }
+RawField.description = 'Set an interface directly.';
+export default RawField;

package/build/esm/fields/SchemaField.d.ts

@@ -5,7 +5,7 @@ import AbstractField from './AbstractField';
 import { ValidateOptions, ToValueTypeOptions, FieldDefinitionValueType } from './field.static.types';
 import { SchemaFieldFieldDefinition } from './SchemaField.types';
 export default class SchemaField<F extends SchemaFieldFieldDefinition = SchemaFieldFieldDefinition> extends AbstractField<F> {
-    static get description(): string;
+    static readonly description = "A way to map relationships.";
     static mapFieldDefinitionToSchemasOrIdsWithVersion(field: SchemaFieldFieldDefinition): (SchemaIdWithVersion | Schema)[];
     static mapFieldDefinitionToSchemaIdsWithVersion(field: SchemaFieldFieldDefinition): SchemaIdWithVersion[];
     static generateTypeDetails(): {

package/build/esm/fields/SchemaField.js

@@ -8,10 +8,7 @@ import isIdWithVersion from '../utilities/isIdWithVersion.js';
 import normalizeSchemaToIdWithVersion from '../utilities/normalizeSchemaToIdWithVersion.js';
 import validateSchema from '../utilities/validateSchema.js';
 import AbstractField from './AbstractField.js';
-export default class SchemaField extends AbstractField {
-    static get description() {
-        return 'A way to map relationships.';
-    }
+class SchemaField extends AbstractField {
     static mapFieldDefinitionToSchemasOrIdsWithVersion(field) {
         const { options } = field;
         const schemasOrIds = [
@@ -70,7 +67,7 @@ export default class SchemaField extends AbstractField {
                     if (!item.namespace) {
                         throwInvalidReferenceError(item);
                     }
-                    return item.namespace.toLowerCase() === namespace.toLowerCase();
+                    return (item.namespace.toLowerCase() === namespace.toLowerCase());
                 });
             }
             let matchedTemplateItem;
@@ -97,7 +94,8 @@ export default class SchemaField extends AbstractField {
                     valueType = `${globalNamespace}.${matchedTemplateItem.namespace}${version ? `.${version}` : ''}${renderAs === TemplateRenderAs.Type
                         ? `.${matchedTemplateItem.namePascal + typeSuffix}`
                         : `.${matchedTemplateItem.namePascal}Schema`}`;
-                    if (renderAs === TemplateRenderAs.Type && idsWithVersion.length > 1) {
+                    if (renderAs === TemplateRenderAs.Type &&
+                        idsWithVersion.length > 1) {
                         valueType = `{ schemaId: '${id}'${version ? `, version: '${version}'` : ''}, values: ${valueType} }`;
                     }
                 }
@@ -119,11 +117,14 @@ export default class SchemaField extends AbstractField {
             valueType =
                 unions.length === 1
                     ? unions[0].valueType
-                    : '[' + unions.map((item) => item.valueType).join(', ') + ']';
+                    : '[' +
+                        unions.map((item) => item.valueType).join(', ') +
+                        ']';
         }
         else {
             valueType = unions.map((item) => item.valueType).join(' | ');
-            valueType = `${(definition.isArray || renderAs === TemplateRenderAs.SchemaType) &&
+            valueType = `${(definition.isArray ||
+                renderAs === TemplateRenderAs.SchemaType) &&
                 unions.length > 1
                 ? `(${valueType})`
                 : `${valueType}`}${(definition.isArray && renderAs === TemplateRenderAs.Type) ||
@@ -204,7 +205,8 @@ export default class SchemaField extends AbstractField {
                             name: this.name,
                             label: this.label,
                             code: 'INVALID_PARAMETER',
-                            friendlyMessage: 'You need to add `values` to the value of ' + this.name,
+                            friendlyMessage: 'You need to add `values` to the value of ' +
+                                this.name,
                         });
                     }
                     else if (!schemaId) {
@@ -212,17 +214,21 @@ export default class SchemaField extends AbstractField {
                             name: this.name,
                             label: this.label,
                             code: 'INVALID_PARAMETER',
-                            friendlyMessage: 'You need to add `schemaId` to the value of ' + this.name,
+                            friendlyMessage: 'You need to add `schemaId` to the value of ' +
+                                this.name,
                         });
                     }
                     else {
-                        const matchSchema = schemas.find((schema) => schema.id === schemaId && schema.version === version);
+                        const matchSchema = schemas.find((schema) => schema.id === schemaId &&
+                            schema.version === version);
                         if (!matchSchema) {
                             errors.push({
                                 name: this.name,
                                 label: this.label,
                                 code: 'INVALID_PARAMETER',
-                                friendlyMessage: `Could not find a schema by id '${schemaId}'${version ? ` and version '${version}'` : ' with no version'}.`,
+                                friendlyMessage: `Could not find a schema by id '${schemaId}'${version
+                                    ? ` and version '${version}'`
+                                    : ' with no version'}.`,
                             });
                         }
                         else {
@@ -267,7 +273,9 @@ export default class SchemaField extends AbstractField {
         }
         const { createEntityInstances, schemasById: schemasById = {} } = options || {};
         // try and pull the schema definition from the options and by id
-        const destinationSchemas = SchemaField.mapFieldDefinitionToSchemas(this.definition, { schemasById });
+        const destinationSchemas = SchemaField.mapFieldDefinitionToSchemas(this.definition, {
+            schemasById,
+        });
         const isUnion = destinationSchemas.length > 1;
         let instance;
         if (value instanceof AbstractEntity) {
@@ -320,6 +328,8 @@ export default class SchemaField extends AbstractField {
         return instance.getValues(getValueOptions);
     }
 }
+SchemaField.description = 'A way to map relationships.';
+export default SchemaField;
 function throwInvalidReferenceError(item) {
     throw new SpruceError({
         code: 'INVALID_SCHEMA_REFERENCE',

package/build/esm/fields/SchemaField.types.d.ts

@@ -15,14 +15,14 @@ export interface SchemaFieldOptions {
     /** Dropped in after the type. Used to generate generics, like <T> */
     typeSuffix?: string;
 }
-export type SchemaFieldUnion<S extends Array<Schema>, CreateEntityInstances extends boolean = false> = {
+export type SchemaFieldUnion<S extends Schema[], CreateEntityInstances extends boolean = false> = {
     [K in keyof S]: S[K] extends Schema ? CreateEntityInstances extends true ? StaticSchemaEntity<S[K]> : {
         schemaId: S[K]['id'];
         version?: S[K]['version'];
         values: SchemaValues<S[K]>;
     } : any;
 };
-export type SchemaFieldValueTypeMapper<F extends SchemaFieldFieldDefinition, CreateEntityInstances extends boolean = false, ShouldIncludeNullAndUndefinedFields extends boolean = false> = F['options']['schemas'] extends Array<Schema> ? IsArrayNoUnpack<SchemaFieldUnion<F['options']['schemas'], CreateEntityInstances>[number], F['isArray']> : F['options']['schema'] extends Schema ? CreateEntityInstances extends true ? IsArray<StaticSchemaEntity<F['options']['schema']>, F['isArray']> : IsArray<SchemaValues<F['options']['schema'], false, true, ShouldIncludeNullAndUndefinedFields>, F['isArray']> : any;
+export type SchemaFieldValueTypeMapper<F extends SchemaFieldFieldDefinition, CreateEntityInstances extends boolean = false, ShouldIncludeNullAndUndefinedFields extends boolean = false> = F['options']['schemas'] extends Schema[] ? IsArrayNoUnpack<SchemaFieldUnion<F['options']['schemas'], CreateEntityInstances>[number], F['isArray']> : F['options']['schema'] extends Schema ? CreateEntityInstances extends true ? IsArray<StaticSchemaEntity<F['options']['schema']>, F['isArray']> : IsArray<SchemaValues<F['options']['schema'], false, true, ShouldIncludeNullAndUndefinedFields>, F['isArray']> : any;
 export type SchemaFieldFieldDefinition = FieldDefinition<Record<string, any>, Record<string, any>, SchemaFieldValueUnion[], SchemaFieldValueUnion[]> & {
     /** * .Schema go team! */
     type: 'schema';

package/build/esm/fields/SelectField.d.ts

@@ -3,7 +3,7 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { SelectFieldDefinition, SelectChoice } from './SelectField.types';
 export default class SelectField<T extends SelectFieldDefinition = SelectFieldDefinition> extends AbstractField<T> {
-    static get description(): string;
+    static readonly description = "Stored as string, lets user select between available options.";
     constructor(name: string, definition: T);
     static generateTypeDetails(): {
         valueTypeMapper: string;

package/build/esm/fields/SelectField.js

@@ -1,9 +1,6 @@
 import { selectChoicesToHash } from '../utilities/selectChoicesToHash.js';
 import AbstractField from './AbstractField.js';
-export default class SelectField extends AbstractField {
-    static get description() {
-        return 'Stored as string, lets user select between available options.';
-    }
+class SelectField extends AbstractField {
     constructor(name, definition) {
         super(name, definition);
         if (!definition.options || !definition.options.choices) {
@@ -41,3 +38,5 @@ export default class SelectField extends AbstractField {
         return this.definition.options.choices;
     }
 }
+SelectField.description = 'Stored as string, lets user select between available options.';
+export default SelectField;

package/build/esm/fields/TextField.d.ts

@@ -4,7 +4,7 @@ import AbstractField from './AbstractField';
 import { ToValueTypeOptions, ValidateOptions } from './field.static.types';
 import { TextFieldDefinition } from './TextField.types';
 export default class TextField extends AbstractField<TextFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A text field. Converts non-strings into strings by calling toString(). Size set by options.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<TextFieldDefinition>): FieldTemplateDetails;
     validate(value: any, options: ValidateOptions<TextFieldDefinition>): FieldError[];
     toValueType<C extends boolean>(value: any, options?: ToValueTypeOptions<TextFieldDefinition, C>): string;

package/build/esm/fields/TextField.js

@@ -1,9 +1,6 @@
 import SpruceError from '../errors/SpruceError.js';
 import AbstractField from './AbstractField.js';
-export default class TextField extends AbstractField {
-    static get description() {
-        return 'A text field. Converts non-strings into strings by calling toString(). Size set by options.';
-    }
+class TextField extends AbstractField {
     static generateTemplateDetails(options) {
         const { definition } = options;
         return {
@@ -59,6 +56,11 @@ export default class TextField extends AbstractField {
     convertToString(value) {
         return typeof value === 'string'
             ? value
-            : typeof value === 'number' && value && value.toString && value.toString();
+            : typeof value === 'number' &&
+                value &&
+                value.toString &&
+                value.toString();
     }
 }
+TextField.description = 'A text field. Converts non-strings into strings by calling toString(). Size set by options.';
+export default TextField;

package/build/esm/fields/field.static.types.d.ts

@@ -2,10 +2,8 @@ import { FieldDefinitions, FieldMap, FieldValueTypeGeneratorMap } from "./../.sp
 import { FieldError } from '../errors/options.types';
 import { Schema, SchemaFieldsByName, SchemaValues, StaticSchemaEntity } from '../schemas.static.types';
 import { Unpack, IsArray, IsRequired } from '../types/utilities.types';
-export interface SchemasById {
-    [id: string]: Schema[];
-}
-export type SchemaFieldUnion<S extends Array<Schema>, CreateEntityInstances extends boolean = false> = {
+export type SchemasById = Record<string, Schema[]>;
+export type SchemaFieldUnion<S extends Schema[], CreateEntityInstances extends boolean = false> = {
     [K in keyof S]: S[K] extends Schema ? CreateEntityInstances extends true ? StaticSchemaEntity<S[K]> : {
         schemaId: S[K]['id'];
         version?: S[K]['version'];

package/build/esm/schemas.static.types.d.ts

@@ -39,9 +39,7 @@ export interface DynamicSchemaEntityByName<ISchema extends Schema, OurField exte
     validate(options?: DynamicSchemaValidateOptions): void;
     isValid(options?: DynamicSchemaValidateOptions): boolean;
 }
-export interface SchemaFieldsByName {
-    [fieldName: string]: FieldDefinitions;
-}
+export type SchemaFieldsByName = Record<string, FieldDefinitions>;
 export interface Schema {
     id: string;
     name?: string;
@@ -70,18 +68,13 @@ export type SchemaAllValues<S extends Schema, CreateEntityInstances extends bool
 export type StaticSchemaAllValues<S extends Schema, CreateEntityInstances extends boolean = false> = {
     [K in SchemaFieldNames<S>]-?: SchemaFieldValueType<S, K, CreateEntityInstances>;
 };
-export type DynamicSchemaAllValues<S extends Schema, CreateEntityInstances extends boolean = false> = {
-    [dynamicKey: string]: S['dynamicFieldSignature'] extends FieldDefinitions ? FieldDefinitionValueType<S['dynamicFieldSignature'], CreateEntityInstances> : never;
-};
+export type DynamicSchemaAllValues<S extends Schema, CreateEntityInstances extends boolean = false> = Record<string, S['dynamicFieldSignature'] extends FieldDefinitions ? FieldDefinitionValueType<S['dynamicFieldSignature'], CreateEntityInstances> : never>;
 export type SchemaPartialValues<S extends Schema, CreateEntityInstances extends boolean = false> = IsDynamicSchema<S> extends true ? DynamicSchemaPartialValues<S, CreateEntityInstances> : StaticSchemaPartialValues<S, CreateEntityInstances>;
 export type StaticSchemaPartialValues<T extends Schema, CreateEntityInstances extends boolean = false> = {
     [K in SchemaFieldNames<T>]?: SchemaFieldValueType<T, K, CreateEntityInstances> | undefined | null;
 };
-export type DynamicSchemaPartialValues<S extends Schema, CreateEntityInstances extends boolean = false> = Partial<{
-    [dynamicField: string]: S['dynamicFieldSignature'] extends FieldDefinitions ? FieldDefinitionValueType<S['dynamicFieldSignature'], CreateEntityInstances> | undefined | null : never;
-}>;
+export type DynamicSchemaPartialValues<S extends Schema, CreateEntityInstances extends boolean = false> = Partial<Record<string, S['dynamicFieldSignature'] extends FieldDefinitions ? FieldDefinitionValueType<S['dynamicFieldSignature'], CreateEntityInstances> | undefined | null : never>>;
 export type SchemaStaticValues<T extends Schema, CreateEntityInstances extends boolean = false, K extends SchemaOptionalFieldNames<T> = SchemaOptionalFieldNames<T>, V extends SchemaAllValues<T, CreateEntityInstances> = SchemaAllValues<T, CreateEntityInstances>> = Omit<V, K> & Partial<Pick<V, K>>;
-export type SchemaValues_OLD<S extends Schema, CreateEntityInstances extends boolean = false> = IsDynamicSchema<S> extends true ? DynamicSchemaAllValues<S> : SchemaStaticValues<S, CreateEntityInstances>;
 export type IsDynamicSchema<S extends Schema> = S['dynamicFieldSignature'] extends FieldDefinitions ? true : false;
 export type SchemaDefaultValues<S extends Schema, CreateEntityInstances extends boolean = false, K extends SchemaFieldNamesWithDefaultValue<S> = SchemaFieldNamesWithDefaultValue<S>, V extends SchemaAllValues<S, CreateEntityInstances> = SchemaAllValues<S, CreateEntityInstances>> = {
     [F in K]: NonNullable<V[F]>;

package/build/esm/tests/validationErrorAssert.utility.d.ts

@@ -1,8 +1,8 @@
-type ValidationErrorAssertOptions = {
+interface ValidationErrorAssertOptions {
     missing?: string[];
     invalid?: string[];
     unexpected?: string[];
-};
+}
 export type ValidationErrorAssertOptionsKey = keyof ValidationErrorAssertOptions;
 declare const validationErrorAssert: {
     assertError(error: any, options: ValidationErrorAssertOptions): void;

package/build/esm/types/utilities.types.d.ts

@@ -1,6 +1,6 @@
 import { Schema, SchemaRequiredFieldNames } from '../schemas.static.types';
-export type Unpack<A> = A extends Array<infer E> ? E : A;
-export type IsArray<T, isArray> = isArray extends true ? Unpack<T>[] : Unpack<T>;
-export type IsArrayNoUnpack<T, isArray> = isArray extends true ? T[] : T;
-export type IsRequired<T, isRequired> = isRequired extends true ? T : T | undefined | null;
+export type Unpack<A> = A extends (infer E)[] ? E : A;
+export type IsArray<T, IsArray> = IsArray extends true ? Unpack<T>[] : Unpack<T>;
+export type IsArrayNoUnpack<T, IsArray> = IsArray extends true ? T[] : T;
+export type IsRequired<T, IsRequired> = IsRequired extends true ? T : T | undefined | null;
 export type AreAnyFieldsRequired<S extends Schema | undefined> = S extends Schema ? SchemaRequiredFieldNames<S> extends [] ? false : true : false;

package/build/esm/utilities/KeyMapper.js

@@ -25,7 +25,6 @@ export default class KeyMapper {
     }
     mapFieldNameFrom(name) {
         for (const key in this.map) {
-            // eslint-disable-next-line no-prototype-builtins
             if (this.map.hasOwnProperty(key)) {
                 if (this.map[key] === name) {
                     return key;
@@ -39,7 +38,6 @@ export default class KeyMapper {
         const foundFields = [];
         let target = {};
         for (const key in map) {
-            // eslint-disable-next-line no-prototype-builtins
             if (values.hasOwnProperty(key)) {
                 target[map[key]] = values[key];
                 foundFields.push(key);
@@ -56,7 +54,6 @@ export default class KeyMapper {
         let target = {};
         for (const targetKey in map) {
             const sourceKey = map[targetKey];
-            // eslint-disable-next-line no-prototype-builtins
             if (values.hasOwnProperty(sourceKey)) {
                 target[targetKey] = values[sourceKey];
                 foundFields.push(sourceKey);

package/build/esm/utilities/cloneDeep.js

@@ -24,7 +24,8 @@ export default function cloneDeep(obj, transformer) {
     if (type == 'Array' || type == 'Object') {
         result = Array.isArray(o) ? [] : {};
         for (let key in o) {
-            result[key] = (_a = transformer === null || transformer === void 0 ? void 0 : transformer(o[key], key)) !== null && _a !== void 0 ? _a : cloneDeep(o[key], transformer);
+            result[key] =
+                (_a = transformer === null || transformer === void 0 ? void 0 : transformer(o[key], key)) !== null && _a !== void 0 ? _a : cloneDeep(o[key], transformer);
         }
     }
     // primitives and non-supported objects (e.g. functions) land here

package/build/esm/utilities/formatPhoneNumber.js

@@ -32,7 +32,7 @@ export function isValidNumber(number) {
 }
 function getCode(number) {
     let code = `1`; // Default to North American country code
-    const cleaned = number.replace(/\D/g, '');
+    const cleaned = number.replace(/(?!^\+)[^\d]/g, '');
     // Explicitly check for '+' sign to distinguish international codes
     if (cleaned.startsWith('+90') ||
         (cleaned.startsWith('90') && cleaned.length > 10)) {
@@ -59,7 +59,9 @@ export default function formatPhoneNumber(val, shouldFailSilently = true) {
             return val;
         }
     }
-    return formatted;
+    // remove trailing spaces
+    const cleaned = formatted.replace(/\s+$/, '');
+    return cleaned;
 }
 export function isDummyNumber(phone) {
     const cleanedValue = phone.replace(/\D/g, '');

package/build/esm/utilities/mapFieldErrorsToParameterErrors.js

@@ -30,7 +30,9 @@ function pullParamaterIssues(errors, prefix = '') {
     const invalidParameters = [];
     const unexpectedParamaters = [];
     errors.forEach((fieldError) => {
-        const fieldName = prefix ? `${prefix}.${fieldError.name}` : fieldError.name;
+        const fieldName = prefix
+            ? `${prefix}.${fieldError.name}`
+            : fieldError.name;
         if (fieldError.errors) {
             const { missingParameters: m, invalidParameters: i, unexpectedParamaters: u, } = pullParamaterIssues(fieldError.errors, fieldName);
             missingParameters.push(...m);

package/build/esm/utilities/registerFieldType.js

@@ -1,7 +1,5 @@
 import SpruceError from '../errors/SpruceError.js';
-export function validateFieldRegistration(registration
-// eslint-disable-next-line no-undef
-) {
+export function validateFieldRegistration(registration) {
     const errors = [];
     const builtRegistration = {
         package: '***missing***',

package/build/esm/utilities/validateSchemaValues.js

@@ -12,9 +12,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 import set from 'just-safe-set';
 import { validateSchema } from '../index.js';
 import EntityFactory from '../factories/SchemaEntityFactory.js';
-export default function validateSchemaValues(schema, values, options
-// eslint-disable-next-line no-undef
-) {
+export default function validateSchemaValues(schema, values, options) {
     const opts = __rest(options !== null && options !== void 0 ? options : {}, []);
     validateSchema(schema);
     const mapped = Object.keys(values).reduce((mapped, key) => {

package/build/fields/AbstractField.js

@@ -6,6 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const isUndefinedOrNull_1 = __importDefault(require("../utilities/isUndefinedOrNull"));
 class AbstractField {
+    /** The definition for this field */
+    definition;
+    /** Shortcut to this field */
+    type;
+    /** The name of this field (camel case) */
+    name;
     constructor(name, definition) {
         this.definition = definition;
         this.name = name;
@@ -65,8 +71,7 @@ public static generateTemplateDetails(
         return this.definition.hint;
     }
     get minArrayLength() {
-        var _a;
-        return (_a = this.definition.minArrayLength) !== null && _a !== void 0 ? _a : 1;
+        return this.definition.minArrayLength ?? 1;
     }
     validate(value, _) {
         const errors = [];

package/build/fields/AddressField.d.ts

@@ -2,6 +2,6 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { AddressFieldDefinition } from './AddressField.types';
 export default class AddressField extends AbstractField<AddressFieldDefinition> {
-    static get description(): string;
+    static readonly description = "An address with geocoding ability *coming soon*";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<AddressFieldDefinition>): FieldTemplateDetails;
 }

package/build/fields/AddressField.js

@@ -5,9 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class AddressField extends AbstractField_1.default {
-    static get description() {
-        return 'An address with geocoding ability *coming soon*';
-    }
+    static description = 'An address with geocoding ability *coming soon*';
     static generateTemplateDetails(options) {
         return {
             valueType: `${options.importAs}.AddressFieldValue${options.definition.isArray ? '[]' : ''}`,

package/build/fields/BooleanField.d.ts

@@ -2,7 +2,7 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { BooleanFieldDefinition } from './BooleanField.types';
 export default class BooleanField extends AbstractField<BooleanFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A true/false. Converts false string to false, all other strings to true.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<BooleanFieldDefinition>): FieldTemplateDetails;
     /** * Turn everything into a string */
     toValueType(value: any): boolean;

package/build/fields/BooleanField.js

@@ -5,9 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class BooleanField extends AbstractField_1.default {
-    static get description() {
-        return 'A true/false. Converts false string to false, all other strings to true.';
-    }
+    static description = 'A true/false. Converts false string to false, all other strings to true.';
     static generateTemplateDetails(options) {
         return {
             valueType: `boolean${options.definition.isArray ? '[]' : ''}`,

package/build/fields/DateField.d.ts

@@ -4,7 +4,7 @@ import AbstractField from './AbstractField';
 import { DateFieldDefinition } from './DateField.types';
 import { ValidateOptions } from './field.static.types';
 export default class DateField extends AbstractField<DateFieldDefinition> {
-    static get description(): string;
+    static readonly description = "Date and time support.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<DateFieldDefinition>): FieldTemplateDetails;
     validate(value: any, options?: ValidateOptions<DateFieldDefinition>): FieldError[];
     toValueType(value: any): any;

package/build/fields/DateField.js

@@ -8,9 +8,7 @@ const getStartOfDay_1 = __importDefault(require("../utilities/getStartOfDay"));
 const isUndefinedOrNull_1 = __importDefault(require("../utilities/isUndefinedOrNull"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class DateField extends AbstractField_1.default {
-    static get description() {
-        return 'Date and time support.';
-    }
+    static description = 'Date and time support.';
     static generateTemplateDetails(options) {
         return {
             valueType: `${options.importAs}.DateFieldValue${options.definition.isArray ? '[]' : ''}`,

package/build/fields/DateTimeField.d.ts

@@ -4,7 +4,7 @@ import AbstractField from './AbstractField';
 import { DateTimeFieldDefinition } from './DateTimeField.types';
 import { ValidateOptions } from './field.static.types';
 export default class DateTimeField extends AbstractField<DateTimeFieldDefinition> {
-    static get description(): string;
+    static readonly description = "Date and time support.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<DateTimeFieldDefinition>): FieldTemplateDetails;
     validate(value: any, options?: ValidateOptions<DateTimeFieldDefinition>): FieldError[];
     toValueType(value: any): any;

package/build/fields/DateTimeField.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 const DateField_1 = require("./DateField");
 class DateTimeField extends AbstractField_1.default {
-    static get description() {
-        return 'Date and time support.';
-    }
+    static description = 'Date and time support.';
     static generateTemplateDetails(options) {
         return {
             valueType: `${options.importAs}.DateTimeFieldValue${options.definition.isArray ? '[]' : ''}`,
@@ -26,12 +24,11 @@ class DateTimeField extends AbstractField_1.default {
         });
     }
     toValueType(value) {
-        var _a;
         let normalized = value;
         if (normalized instanceof Date) {
             normalized = normalized.getTime();
         }
-        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.dateTimeFormat) === 'iso_8601') {
+        if (this.options?.dateTimeFormat === 'iso_8601') {
             return new Date(value).toISOString();
         }
         if (typeof normalized === 'string') {

package/build/fields/DirectoryField.d.ts

@@ -3,7 +3,7 @@ import AbstractField from './AbstractField';
 import { DirectoryFieldDefinition, DirectoryFieldValue } from './DirectoryField.types';
 import { ToValueTypeOptions } from './field.static.types';
 export default class DirectoryField extends AbstractField<DirectoryFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A way to select entire directories once!";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<DirectoryFieldDefinition>): FieldTemplateDetails;
     toValueType<C extends boolean>(value: any, options?: ToValueTypeOptions<DirectoryFieldDefinition, C>): DirectoryFieldValue;
 }