@sprucelabs/schema 29.4.60 → 30.0.0

package/build/fields/DirectoryField.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class DirectoryField extends AbstractField_1.default {
-    static get description() {
-        return 'A way to select entire directories once!';
-    }
+    static description = 'A way to select entire directories once!';
     static generateTemplateDetails(options) {
         const { definition } = options;
         return {
@@ -16,9 +14,11 @@ class DirectoryField extends AbstractField_1.default {
         };
     }
     toValueType(value, options) {
-        const stringValue = typeof value === 'string' || value.toString ? value.toString() : undefined;
+        const stringValue = typeof value === 'string' || value.toString
+            ? value.toString()
+            : undefined;
         let path;
-        const relativeTo = options === null || options === void 0 ? void 0 : options.relativeTo;
+        const relativeTo = options?.relativeTo;
         if (stringValue) {
             path = stringValue;
         }
@@ -35,9 +35,10 @@ class DirectoryField extends AbstractField_1.default {
             });
         }
         if (path && relativeTo) {
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
             const pathUtil = require('path');
-            path = pathUtil.relative(relativeTo, path) || path;
+            path =
+                pathUtil.relative(relativeTo, path) ||
+                    path;
         }
         return { path };
     }

package/build/fields/DurationField.d.ts

@@ -7,7 +7,7 @@ import { TextFieldDefinition } from './TextField.types';
 export declare function reduceDurationToMs(duration: Partial<DurationFieldValue>): number;
 export declare function buildDuration(value: string | number | Partial<DurationFieldValue>): DurationFieldValue;
 export default class DurationField extends AbstractField<DurationFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A span of time represented in { hours, minutes, seconds, ms }";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<DurationFieldDefinition>): FieldTemplateDetails;
     validate(value: any, _?: ValidateOptions<TextFieldDefinition>): FieldError[];
     toValueType(value: any): DurationFieldValue;

package/build/fields/DurationField.js

@@ -27,7 +27,8 @@ function buildDuration(value) {
     else if (typeof value === 'object') {
         totalMs += typeof value.ms === 'number' ? value.ms : 0;
         totalMs += typeof value.seconds === 'number' ? value.seconds * 1000 : 0;
-        totalMs += typeof value.minutes === 'number' ? value.minutes * 1000 * 60 : 0;
+        totalMs +=
+            typeof value.minutes === 'number' ? value.minutes * 1000 * 60 : 0;
         totalMs +=
             typeof value.hours === 'number' ? value.hours * 1000 * 60 * 60 : 0;
     }
@@ -48,16 +49,13 @@ function buildDuration(value) {
 }
 exports.buildDuration = buildDuration;
 class DurationField extends AbstractField_1.default {
-    static get description() {
-        return 'A span of time represented in { hours, minutes, seconds, ms }';
-    }
+    static description = 'A span of time represented in { hours, minutes, seconds, ms }';
     static generateTemplateDetails(options) {
         return {
             valueType: `${options.importAs}.DurationFieldValue${options.definition.isArray ? '[]' : ''}`,
         };
     }
     validate(value, _) {
-        var _a;
         const errors = [];
         try {
             buildDuration(value);
@@ -67,7 +65,7 @@ class DurationField extends AbstractField_1.default {
                 code: 'INVALID_PARAMETER',
                 name: this.name,
                 originalError: err,
-                friendlyMessage: (_a = err.options) === null || _a === void 0 ? void 0 : _a.friendlyMessage,
+                friendlyMessage: err.options?.friendlyMessage,
             });
         }
         return errors;

package/build/fields/EmailField.d.ts

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

package/build/fields/EmailField.js

@@ -29,9 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const EmailValidator = __importStar(require("email-validator"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class EmailField extends AbstractField_1.default {
-    static get description() {
-        return 'Email support.';
-    }
+    static description = 'Email support.';
     static generateTemplateDetails(options) {
         return {
             valueType: `string${options.definition.isArray ? '[]' : ''}`,

package/build/fields/FileField.d.ts

@@ -4,7 +4,7 @@ import AbstractField from './AbstractField';
 import { ToValueTypeOptions, ValidateOptions } from './field.static.types';
 import { FileFieldDefinition, FileFieldValue } from './FileField.types';
 export default class FileField extends AbstractField<FileFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A way to handle files. Supports mime-type lookups.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<FileFieldDefinition>): FieldTemplateDetails;
     validate(value: FileFieldValue, _?: ValidateOptions<FileFieldDefinition>): FieldError[];
     toValueType<C extends boolean>(value: any, _options?: ToValueTypeOptions<FileFieldDefinition, C>): FileFieldValue;

package/build/fields/FileField.js

@@ -5,18 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class FileField extends AbstractField_1.default {
-    static get description() {
-        return 'A way to handle files. Supports mime-type lookups.';
-    }
+    static description = 'A way to handle files. Supports mime-type lookups.';
     static generateTemplateDetails(options) {
         return {
             valueType: `${options.importAs}.FileFieldValue${options.definition.isArray ? '[]' : ''}`,
         };
     }
     validate(value, _) {
-        var _a, _b, _c;
         const errors = super.validate(value);
-        const acceptableTypes = (_b = (_a = this.definition.options) === null || _a === void 0 ? void 0 : _a.acceptableTypes) !== null && _b !== void 0 ? _b : [];
+        const acceptableTypes = this.definition.options?.acceptableTypes ?? [];
         if (value &&
             !value.base64 &&
             acceptableTypes[0] !== '*' &&
@@ -24,7 +21,7 @@ class FileField extends AbstractField_1.default {
             errors.push({
                 code: 'INVALID_PARAMETER',
                 name: this.name,
-                friendlyMessage: `You sent a '${value.type}' to '${(_c = this.label) !== null && _c !== void 0 ? _c : this.name}' and it only accepts '${acceptableTypes.join("', '")}'.`,
+                friendlyMessage: `You sent a '${value.type}' to '${this.label ?? this.name}' and it only accepts '${acceptableTypes.join("', '")}'.`,
             });
         }
         return errors;

package/build/fields/IdField.d.ts

@@ -2,7 +2,7 @@ import { FieldTemplateDetailOptions, FieldTemplateDetails } from '../types/templ
 import AbstractField from './AbstractField';
 import { IdFieldDefinition } from './IdField.types';
 export default class IdField extends AbstractField<IdFieldDefinition> {
-    static get description(): string;
+    static readonly description = "A unique identifier field.";
     static generateTemplateDetails(options: FieldTemplateDetailOptions<IdFieldDefinition>): FieldTemplateDetails;
     toValueType(value: any): string;
 }

package/build/fields/IdField.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 IdField extends AbstractField_1.default {
-    static get description() {
-        return 'A unique identifier field.';
-    }
+    static description = 'A unique identifier field.';
     static generateTemplateDetails(options) {
         return {
             valueType: `string${options.definition.isArray ? '[]' : ''}`,

package/build/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/fields/ImageField.js

@@ -12,11 +12,8 @@ class ImageField extends AbstractField_1.default {
             valueType: `${importAs}.ImageFieldValue${definition.isArray ? '[]' : ''}`,
         };
     }
-    static get description() {
-        return 'Images of various sizes!';
-    }
+    static description = 'Images of various sizes!';
     validate(value) {
-        var _a;
         const errors = super.validate(value);
         if (value && errors.length === 0 && !value.base64) {
             let sizes = this.getRequiredSizes();
@@ -32,15 +29,14 @@ class ImageField extends AbstractField_1.default {
                 errors.push({
                     code: 'INVALID_PARAMETER',
                     name: this.name,
-                    friendlyMessage: `You need to supply the remaining sizes to upload an image to ${(_a = this.label) !== null && _a !== void 0 ? _a : this.name}: '${missing.join("', '")}'`,
+                    friendlyMessage: `You need to supply the remaining sizes to upload an image to ${this.label ?? this.name}: '${missing.join("', '")}'`,
                 });
             }
         }
         return errors;
     }
     getRequiredSizes() {
-        var _a, _b;
-        let sizes = (_b = (_a = this.definition.options) === null || _a === void 0 ? void 0 : _a.requiredSizes) !== null && _b !== void 0 ? _b : [];
+        let sizes = this.definition.options?.requiredSizes ?? [];
         if (sizes[0] === '*') {
             sizes = ImageField_types_1.requiredImageSizes.filter((s) => s !== '*');
         }

package/build/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/fields/NumberField.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class NumberField extends AbstractField_1.default {
-    static get description() {
-        return 'Handles all types of numbers with min/max and clamp support';
-    }
+    static description = 'Handles all types of numbers with min/max and clamp support';
     static generateTemplateDetails(options) {
         return {
             valueType: `number${options.definition.isArray ? '[]' : ''}`,

package/build/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/fields/PhoneField.js

@@ -29,9 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const formatPhoneNumber_1 = __importStar(require("../utilities/formatPhoneNumber"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class PhoneField extends AbstractField_1.default {
-    static get description() {
-        return 'Takes anything close to a phone number and formats it. Also great at validating numbers.';
-    }
+    static description = 'Takes anything close to a phone number and formats it. Also great at validating numbers.';
     static generateTemplateDetails(options) {
         return {
             valueType: `string${options.definition.isArray ? '[]' : ''}`,

package/build/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/fields/RawField.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 RawField extends AbstractField_1.default {
-    static get description() {
-        return 'Set an interface directly.';
-    }
+    static description = 'Set an interface directly.';
     static generateTemplateDetails(options) {
         return {
             valueType: `(${options.definition.options.valueType})${options.definition.isArray ? '[]' : ''}`,

package/build/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/fields/SchemaField.js

@@ -14,9 +14,7 @@ const normalizeSchemaToIdWithVersion_1 = __importDefault(require("../utilities/n
 const validateSchema_1 = __importDefault(require("../utilities/validateSchema"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class SchemaField extends AbstractField_1.default {
-    static get description() {
-        return 'A way to map relationships.';
-    }
+    static description = 'A way to map relationships.';
     static mapFieldDefinitionToSchemasOrIdsWithVersion(field) {
         const { options } = field;
         const schemasOrIds = [
@@ -75,7 +73,7 @@ class SchemaField extends AbstractField_1.default {
                     if (!item.namespace) {
                         throwInvalidReferenceError(item);
                     }
-                    return item.namespace.toLowerCase() === namespace.toLowerCase();
+                    return (item.namespace.toLowerCase() === namespace.toLowerCase());
                 });
             }
             let matchedTemplateItem;
@@ -102,7 +100,8 @@ class SchemaField extends AbstractField_1.default {
                     valueType = `${globalNamespace}.${matchedTemplateItem.namespace}${version ? `.${version}` : ''}${renderAs === template_types_1.TemplateRenderAs.Type
                         ? `.${matchedTemplateItem.namePascal + typeSuffix}`
                         : `.${matchedTemplateItem.namePascal}Schema`}`;
-                    if (renderAs === template_types_1.TemplateRenderAs.Type && idsWithVersion.length > 1) {
+                    if (renderAs === template_types_1.TemplateRenderAs.Type &&
+                        idsWithVersion.length > 1) {
                         valueType = `{ schemaId: '${id}'${version ? `, version: '${version}'` : ''}, values: ${valueType} }`;
                     }
                 }
@@ -115,7 +114,7 @@ class SchemaField extends AbstractField_1.default {
                 throw new SpruceError_1.default({
                     code: 'SCHEMA_NOT_FOUND',
                     schemaId: id,
-                    friendlyMessage: `Template generation failed. I could not find a schema that was being referenced. I was looking for a schema with the id of '${id}' and namespace '${namespace !== null && namespace !== void 0 ? namespace : '**missing**'}'.`,
+                    friendlyMessage: `Template generation failed. I could not find a schema that was being referenced. I was looking for a schema with the id of '${id}' and namespace '${namespace ?? '**missing**'}'.`,
                 });
             }
         });
@@ -124,11 +123,14 @@ class SchemaField extends AbstractField_1.default {
             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 === template_types_1.TemplateRenderAs.SchemaType) &&
+            valueType = `${(definition.isArray ||
+                renderAs === template_types_1.TemplateRenderAs.SchemaType) &&
                 unions.length > 1
                 ? `(${valueType})`
                 : `${valueType}`}${(definition.isArray && renderAs === template_types_1.TemplateRenderAs.Type) ||
@@ -154,7 +156,6 @@ class SchemaField extends AbstractField_1.default {
         return schemas;
     }
     validate(value, options) {
-        var _a;
         const errors = super.validate(value, options);
         // do not validate schemas by default, very heavy and only needed when explicitly asked to
         if (value instanceof AbstractEntity_1.default) {
@@ -176,7 +177,7 @@ class SchemaField extends AbstractField_1.default {
                 errors.push({
                     code: 'INVALID_PARAMETER',
                     name: this.name,
-                    friendlyMessage: `${(_a = this.label) !== null && _a !== void 0 ? _a : this.name} must be an object!`,
+                    friendlyMessage: `${this.label ?? this.name} must be an object!`,
                 });
             }
             else {
@@ -209,7 +210,8 @@ class SchemaField extends AbstractField_1.default {
                             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) {
@@ -217,17 +219,21 @@ class SchemaField extends AbstractField_1.default {
                             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 {
@@ -272,7 +278,9 @@ class SchemaField extends AbstractField_1.default {
         }
         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_1.default) {
@@ -315,7 +323,11 @@ class SchemaField extends AbstractField_1.default {
         if (createEntityInstances) {
             return instance;
         }
-        const getValueOptions = Object.assign(Object.assign({ validate: false }, options), { fields: undefined });
+        const getValueOptions = {
+            validate: false,
+            ...options,
+            fields: undefined,
+        };
         if (isUnion) {
             return {
                 schemaId: instance.schemaId,

package/build/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/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/fields/SelectField.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const selectChoicesToHash_1 = require("../utilities/selectChoicesToHash");
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class SelectField extends AbstractField_1.default {
-    static get description() {
-        return 'Stored as string, lets user select between available options.';
-    }
+    static description = 'Stored as string, lets user select between available options.';
     constructor(name, definition) {
         super(name, definition);
         if (!definition.options || !definition.options.choices) {

package/build/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/fields/TextField.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const AbstractField_1 = __importDefault(require("./AbstractField"));
 class TextField extends AbstractField_1.default {
-    static get description() {
-        return 'A text field. Converts non-strings into strings by calling toString(). Size set by options.';
-    }
+    static description = 'A text field. Converts non-strings into strings by calling toString(). Size set by options.';
     static generateTemplateDetails(options) {
         const { definition } = options;
         return {
@@ -37,10 +35,9 @@ class TextField extends AbstractField_1.default {
         return errors;
     }
     toValueType(value, options) {
-        var _a;
         let transformed = this.convertToString(value);
         if (typeof transformed === 'string') {
-            const maxLength = (_a = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _a !== void 0 ? _a : 0;
+            const maxLength = options?.maxLength ?? 0;
             if (maxLength > 0 && transformed.length > maxLength) {
                 transformed = transformed.substr(0, maxLength);
             }
@@ -64,7 +61,10 @@ class TextField extends AbstractField_1.default {
     convertToString(value) {
         return typeof value === 'string'
             ? value
-            : typeof value === 'number' && value && value.toString && value.toString();
+            : typeof value === 'number' &&
+                value &&
+                value.toString &&
+                value.toString();
     }
 }
 exports.default = TextField;

package/build/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/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/singletons/SchemaRegistry.js

@@ -6,9 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const validateSchema_1 = __importDefault(require("../utilities/validateSchema"));
 class SchemaRegistry {
-    constructor() {
-        this.schemasById = {};
-    }
+    schemasById = {};
+    static instance;
     static getInstance() {
         if (!this.instance) {
             this.instance = new SchemaRegistry();
@@ -84,9 +83,8 @@ class SchemaRegistry {
         return true;
     }
     forgetSchema(id, version) {
-        var _a, _b;
-        this.schemasById[id] = (_a = this.schemasById[id]) === null || _a === void 0 ? void 0 : _a.filter((schema) => !(schema.id === id && schema.version === version));
-        if (((_b = this.schemasById[id]) === null || _b === void 0 ? void 0 : _b.length) === 0) {
+        this.schemasById[id] = this.schemasById[id]?.filter((schema) => !(schema.id === id && schema.version === version));
+        if (this.schemasById[id]?.length === 0) {
             delete this.schemasById[id];
         }
     }

package/build/tests/AbstractDateFieldTest.js

@@ -8,6 +8,8 @@ const __1 = require("..");
 const AbstractSchemaTest_1 = __importDefault(require("../AbstractSchemaTest"));
 const SchemaEntityFactory_1 = __importDefault(require("../factories/SchemaEntityFactory"));
 class AbstractDateFieldTest extends AbstractSchemaTest_1.default {
+    static schema;
+    static entity;
     static async beforeEach() {
         await super.beforeEach();
         this.entity = SchemaEntityFactory_1.default.Entity(this.schema);

package/build/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;