@sprucelabs/schema 25.5.63 → 25.5.67

package/build/esm/DynamicSchemaEntityImplementation.d.ts

@@ -1,4 +1,4 @@
-import { FieldMap } from "./../.spruce/schemas/fields/fields.types";
+import { FieldMap } from "./.spruce/schemas/fields/fields.types";
 import AbstractEntity from './AbstractEntity';
 import { FieldDefinitionValueType, Field, FieldDefinition } from './fields/field.static.types';
 import { DynamicSchemaAllValues, DynamicSchemaPartialValues, DynamicSchemaEntityByName, DynamicSchemaGetValuesOptions, DynamicSchemaNamedFieldsOptions, Schema, DynamicSchemaNamedField, SchemaNormalizeOptions, DynamicSchemaValidateOptions, DynamicSchemaNormalizeOptions } from './schemas.static.types';

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

@@ -1,4 +1,4 @@
-import { FieldDefinitions } from "./../../.spruce/schemas/fields/fields.types";
+import { FieldDefinitions } from "./../.spruce/schemas/fields/fields.types";
 import { FieldError } from '../errors/options.types';
 import { FieldTemplateDetails, FieldTemplateDetailOptions } from '../types/template.types';
 import { ValidateOptions, Field } from './field.static.types';

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

@@ -1,4 +1,4 @@
-import { FieldDefinitions, FieldMap, FieldValueTypeGeneratorMap } from "./../../.spruce/schemas/fields/fields.types";
+import { FieldDefinitions, FieldMap, FieldValueTypeGeneratorMap } from "./../.spruce/schemas/fields/fields.types";
 import { FieldError } from '../errors/options.types';
 import { Schema, SchemaValues, StaticSchemaEntity } from '../schemas.static.types';
 import { Unpack, IsArray, IsRequired } from '../types/utilities.types';

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

@@ -1,4 +1,4 @@
-import { FieldDefinitions, Fields, FieldDefinitionMap, FieldMap } from "./../.spruce/schemas/fields/fields.types";
+import { FieldDefinitions, Fields, FieldDefinitionMap, FieldMap } from "./.spruce/schemas/fields/fields.types";
 import { FieldDefinition, FieldDefinitionValueType, Field, FieldType } from './fields/field.static.types';
 export interface SchemaEntity {
     schemaId: string;

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

@@ -1,4 +1,4 @@
-import { Fields, FieldDefinitionMap } from "./../../.spruce/schemas/fields/fields.types";
+import { Fields, FieldDefinitionMap } from "./../.spruce/schemas/fields/fields.types";
 import { FieldDefinitionValueType } from '../fields';
 import { SchemasById } from '../fields/field.static.types';
 import { SchemaNormalizeFieldValueOptions } from '../schemas.static.types';

package/package.json

@@ -8,7 +8,7 @@
     "!build/__tests__",
     "esm"
   ],
-  "version": "25.5.63",
+  "version": "25.5.67",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "module": "./build/esm/index.js",
@@ -33,14 +33,15 @@
   "scripts": {
     "build.ci": "yarn build.tsc && yarn build.resolve-paths && yarn lint",
     "build.dev": "yarn build.tsc --sourceMap ; yarn resolve-paths.lint",
-    "build.dist": "yarn build.tsc && tsc --project tsconfig.dist.json && yarn build.resolve-paths && yarn build.esm-postbuild",
-    "build.tsc": "tsc",
+    "build.dist": "tsc --project tsconfig.dist.json && yarn build.resolve-paths && mv build esm && yarn build.esm-postbuild && yarn build.tsc && yarn build.resolve-paths && mv esm build/ && yarn clean.dist",
+    "build.esm-postbuild": "esm-postbuild --target esm --patterns '**/*.js'",
     "build.resolve-paths": "resolve-path-aliases --target build --patterns '**/*.js,**/*.d.ts'",
-    "build.esm-postbuild": "esm-postbuild --target build/esm --patterns '**/*.js'",
+    "build.tsc": "tsc",
     "clean": "yarn clean.build",
     "clean.all": "yarn clean.dependencies && yarn clean.build",
     "clean.build": "rm -rf build/",
     "clean.dependencies": "rm -rf node_modules/ package-lock.json yarn.lock",
+    "clean.dist": "rm -rf build/__tests__ build/esm/__tests__",
     "fix.lint": "eslint --fix --cache '**/*.ts'",
     "lint": "eslint --cache '**/*.ts'",
     "lint.tsc": "tsc -p . --noEmit",
@@ -60,29 +61,29 @@
     "build.copy-files": "mkdir -p build && rsync -avzq --exclude='*.ts' ./src/ ./build/"
   },
   "dependencies": {
-    "@sprucelabs/error": "^5.0.364",
-    "@sprucelabs/test": "^7.7.268",
+    "@sprucelabs/error": "^5.0.367",
+    "@sprucelabs/test": "^7.7.270",
     "email-validator": "^2.0.4",
     "lodash": "^4.17.21",
     "mime-db": "^1.51.0",
     "mime-type": "^4.0.0"
   },
   "devDependencies": {
-    "@sprucelabs/esm-postbuild": "^1.0.319",
-    "@sprucelabs/jest-json-reporter": "^6.0.301",
-    "@sprucelabs/jest-sheets-reporter": "^1.2.298",
-    "@sprucelabs/resolve-path-aliases": "^1.0.249",
+    "@sprucelabs/esm-postbuild": "^1.0.321",
+    "@sprucelabs/jest-json-reporter": "^6.0.303",
+    "@sprucelabs/jest-sheets-reporter": "^1.2.299",
+    "@sprucelabs/resolve-path-aliases": "^1.0.250",
     "@sprucelabs/semantic-release": "^4.0.8",
-    "@sprucelabs/spruce-test-fixtures": "^20.1.14",
-    "@sprucelabs/test-utils": "^3.0.366",
+    "@sprucelabs/spruce-test-fixtures": "^20.1.15",
+    "@sprucelabs/test-utils": "^3.0.369",
     "@types/lodash": "^4.14.178",
     "@types/mime-db": "^1.43.1",
     "chokidar-cli": "^3.0.0",
     "concurrently": "^7.0.0",
     "eslint": "^8.6.0",
     "eslint-config-spruce": "^10.11.0",
-    "jest": "^27.4.5",
-    "jest-circus": "^27.4.5",
+    "jest": "^27.4.6",
+    "jest-circus": "^27.4.6",
     "prettier": "^2.5.1",
     "ts-node": "^10.4.0",
     "tsc-watch": "^4.6.0",

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

@@ -1,7 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-export default class AssertingSelectOptionsTest extends AbstractSpruceTest {
-    protected static canCreateAssertSelectOptions(): void;
-    protected static knowsIfChoicesDontMatch(choices: any, expected: any): void;
-    protected static knowsIfSingeOptionMatches(options: any, expected: any): void;
-    protected static canType(): void;
-}

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

@@ -1,93 +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 selectAssertUtil from '../../tests/selectAssert.utility.js';
-export default class AssertingSelectOptionsTest extends AbstractSpruceTest {
-    static canCreateAssertSelectOptions() {
-        assert.isFunction(selectAssertUtil.assertSelectChoicesMatch);
-    }
-    static knowsIfChoicesDontMatch(choices, expected) {
-        assert.doesThrow(() => selectAssertUtil.assertSelectChoicesMatch(choices, expected));
-    }
-    static knowsIfSingeOptionMatches(options, expected) {
-        selectAssertUtil.assertSelectChoicesMatch(options, expected);
-    }
-    static canType() {
-        selectAssertUtil.assertSelectChoicesMatch([
-            {
-                value: 'hello',
-                label: 'World!',
-            },
-            {
-                value: 'no',
-                label: 'Way',
-            },
-        ], ['hello', 'no']);
-    }
-}
-__decorate([
-    test()
-], AssertingSelectOptionsTest, "canCreateAssertSelectOptions", null);
-__decorate([
-    test('throws if single option does not match', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-    ], ['no']),
-    test('throws if choices outnumber expected does not match', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-        {
-            value: 'no',
-            label: 'way!',
-        },
-    ], ['no']),
-    test('throws if not all choices match', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-        {
-            value: 'no',
-            label: 'way!',
-        },
-    ], ['no', 'word'])
-], AssertingSelectOptionsTest, "knowsIfChoicesDontMatch", null);
-__decorate([
-    test('matches single choices', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-    ], ['hello']),
-    test('matches in order', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-        {
-            value: 'no',
-            label: 'Way',
-        },
-    ], ['hello', 'no']),
-    test('matches out of order', [
-        {
-            value: 'hello',
-            label: 'World!',
-        },
-        {
-            value: 'no',
-            label: 'Way',
-        },
-    ], ['no', 'hello'])
-], AssertingSelectOptionsTest, "knowsIfSingeOptionMatches", null);
-__decorate([
-    test('is typed correctly (will always pass)')
-], AssertingSelectOptionsTest, "canType", null);

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

@@ -1,18 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import { FieldErrorCode } from '../../errors/options.types';
-import { ValidationErrorAssertOptionsKey } from '../../tests/validationErrorAssert.utility';
-export default class AssertingValidationErrorsTest extends AbstractSpruceTest {
-    protected static canCreateAssertingValidationErrors(): void;
-    protected static throwsWhenMissingErrorAndOptions(): void;
-    protected static throwsWhenMissingOptions(): void;
-    protected static throwsWhenNotGettingSpruceError(): void;
-    protected static passesWhenJustReturnedError(): void;
-    protected static failsWhenMissingNotFound(): void;
-    protected static failsWhenMissingNotFoundWithOtherErrors(): void;
-    protected static failsWhenMissingIsNamedDifferently(): void;
-    protected static failsWhenOneOfTwoMatches(code: FieldErrorCode, key: ValidationErrorAssertOptionsKey, search: RegExp): void;
-    protected static matches(code: FieldErrorCode, key: ValidationErrorAssertOptionsKey): void;
-    protected static throwsWhenCodeMissmatches(): void;
-    protected static matchesNestedParameters(): void;
-    protected static throwWhenMissingOnNested(): void;
-}

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

@@ -1,217 +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 { errorAssertUtil } from '@sprucelabs/test-utils';
-import SpruceError from '../../errors/SpruceError.js';
-import validationErrorAssertUtil from '../../tests/validationErrorAssert.utility.js';
-export default class AssertingValidationErrorsTest extends AbstractSpruceTest {
-    static canCreateAssertingValidationErrors() {
-        assert.isFunction(validationErrorAssertUtil.assertError);
-    }
-    static throwsWhenMissingErrorAndOptions() {
-        const err = assert.doesThrow(
-        //@ts-ignore
-        () => validationErrorAssertUtil.assertError());
-        errorAssertUtil.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['error', 'options'],
-        });
-    }
-    static throwsWhenMissingOptions() {
-        const err = assert.doesThrow(
-        //@ts-ignore
-        () => validationErrorAssertUtil.assertError(new Error('test')));
-        errorAssertUtil.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['options'],
-        });
-    }
-    static throwsWhenNotGettingSpruceError() {
-        const err = assert.doesThrow(() => 
-        //@ts-ignore
-        validationErrorAssertUtil.assertError(new Error('test'), {
-            missing: [],
-        }));
-        errorAssertUtil.assertError(err, 'INVALID_PARAMETERS', {
-            parameters: ['error'],
-        });
-    }
-    static passesWhenJustReturnedError() {
-        validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'MISSING_PARAMETER',
-                    name: 'test',
-                },
-            ],
-        }), {
-            missing: ['test'],
-        });
-    }
-    static failsWhenMissingNotFound() {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [],
-        }), {
-            missing: ['test'],
-        }), /missing.*?test/gis);
-    }
-    static failsWhenMissingNotFoundWithOtherErrors() {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'INVALID_PARAMETER',
-                    name: 'taco',
-                },
-            ],
-        }), {
-            missing: ['test'],
-        }), /missing.*?test/gis);
-    }
-    static failsWhenMissingIsNamedDifferently() {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'MISSING_PARAMETER',
-                    name: 'taco',
-                },
-            ],
-        }), {
-            missing: ['cheesy'],
-        }), /missing|cheesy/gis);
-    }
-    static failsWhenOneOfTwoMatches(code, key, search) {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code,
-                    name: 'taco',
-                },
-            ],
-        }), {
-            [key]: ['taco', 'cheesy'],
-        }), search);
-    }
-    static matches(code, key) {
-        validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code,
-                    name: 'test',
-                },
-            ],
-        }), {
-            [key]: ['test'],
-        });
-    }
-    static throwsWhenCodeMissmatches() {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'MISSING_PARAMETER',
-                    name: 'taco',
-                },
-            ],
-        }), {
-            invalid: ['taco'],
-        }));
-    }
-    static matchesNestedParameters() {
-        validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'INVALID_PARAMETER',
-                    name: 'test',
-                    errors: [
-                        {
-                            code: 'MISSING_PARAMETER',
-                            name: 'turkey',
-                        },
-                    ],
-                },
-            ],
-        }), {
-            missing: ['test.turkey'],
-        });
-    }
-    static throwWhenMissingOnNested() {
-        assert.doesThrow(() => validationErrorAssertUtil.assertError(new SpruceError({
-            code: 'VALIDATION_FAILED',
-            schemaId: 'person',
-            errors: [
-                {
-                    code: 'INVALID_PARAMETER',
-                    name: 'taco',
-                    errors: [
-                        {
-                            code: 'UNEXPECTED_PARAMETER',
-                            name: 'bravo',
-                        },
-                    ],
-                },
-            ],
-        }), {
-            invalid: ['taco.bravo'],
-        }));
-    }
-}
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "canCreateAssertingValidationErrors", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "throwsWhenMissingErrorAndOptions", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "throwsWhenMissingOptions", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "throwsWhenNotGettingSpruceError", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "passesWhenJustReturnedError", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "failsWhenMissingNotFound", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "failsWhenMissingNotFoundWithOtherErrors", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "failsWhenMissingIsNamedDifferently", null);
-__decorate([
-    test('fails when matches only 1 missing', 'MISSING_PARAMETER', 'missing', /missing|cheesy/),
-    test('fails when matches only 1 invalid', 'INVALID_PARAMETER', 'invalid', /invalid|cheesy/),
-    test('fails when matches only 1 unexpected', 'UNEXPECTED_PARAMETER', 'unexpected', /unexpected.*?cheesy/)
-], AssertingValidationErrorsTest, "failsWhenOneOfTwoMatches", null);
-__decorate([
-    test('matching missing', 'MISSING_PARAMETER', 'missing'),
-    test('matching invalid', 'INVALID_PARAMETER', 'invalid'),
-    test('matching unexpected', 'UNEXPECTED_PARAMETER', 'unexpected')
-], AssertingValidationErrorsTest, "matches", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "throwsWhenCodeMissmatches", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "matchesNestedParameters", null);
-__decorate([
-    test()
-], AssertingValidationErrorsTest, "throwWhenMissingOnNested", null);

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

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

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

@@ -1,66 +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());
-    });
-};
-// TODO figure out how to get schema field mixins working from buildSchema (SchemaDefinitionValues fails)
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
-import buildSchema from '../../utilities/buildSchema.js';
-export default class BuildSchemaTest extends AbstractSpruceTest {
-    static testBasicSchemaBuilding() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = buildSchema({
-                id: 'test-1',
-                name: 'test 1',
-                fields: {
-                    firstName: {
-                        type: 'text',
-                    },
-                },
-            });
-            assert.isTruthy(schema);
-            assert.isTruthy(schema.fields.firstName);
-        });
-    }
-    static testBuiltSchemaType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = buildSchema({
-                id: 'test-2',
-                name: 'test two',
-                fields: {
-                    skillName: {
-                        type: 'text',
-                        label: 'Name',
-                        isRequired: true,
-                        hint: "What's the name of your skill?",
-                    },
-                    description: {
-                        type: 'text',
-                        label: 'Description',
-                        isRequired: true,
-                        hint: 'How would you describe your skill?',
-                    },
-                },
-            });
-            const test = (def) => def;
-            test(schema);
-            test(schema);
-        });
-    }
-}
-__decorate([
-    test()
-], BuildSchemaTest, "testBasicSchemaBuilding", null);
-__decorate([
-    test()
-], BuildSchemaTest, "testBuiltSchemaType", null);

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

@@ -1,7 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class CreatingEntityInstancesTest extends AbstractSchemaTest {
-    protected static canCreateStaticEntity(): Promise<void>;
-    protected static typesStaticEntity(): Promise<void>;
-    protected static canCreateDynamicEntity(): Promise<void>;
-    protected static typesDynamicEntity(): Promise<void>;
-}

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

@@ -1,93 +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 DynamicSchemaEntityImplementation from '../../DynamicSchemaEntityImplementation.js';
-import EntityFactory from '../../factories/SchemaEntityFactory.js';
-import StaticSchemaEntityImplementation from '../../StaticSchemaEntityImplementation.js';
-export default class CreatingEntityInstancesTest extends AbstractSchemaTest {
-    static canCreateStaticEntity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = EntityFactory.Entity({
-                id: 'staticPerson',
-                fields: {
-                    firstName: {
-                        type: 'text',
-                        isRequired: true,
-                    },
-                },
-            });
-            assert.isTrue(instance instanceof StaticSchemaEntityImplementation);
-        });
-    }
-    static typesStaticEntity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = EntityFactory.Entity({
-                id: 'staticPerson',
-                fields: {
-                    firstName: {
-                        type: 'text',
-                        isRequired: true,
-                    },
-                },
-            }, {
-                firstName: 'Tay tay',
-            });
-            const values = instance.getValues();
-            assert.isExactType(true);
-        });
-    }
-    static canCreateDynamicEntity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = EntityFactory.Entity({
-                id: 'staticPerson',
-                dynamicFieldSignature: {
-                    type: 'boolean',
-                    keyName: 'key',
-                },
-            });
-            assert.isTrue(instance instanceof DynamicSchemaEntityImplementation);
-        });
-    }
-    static typesDynamicEntity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = EntityFactory.Entity({
-                id: 'staticPerson',
-                dynamicFieldSignature: {
-                    type: 'boolean',
-                    keyName: 'key',
-                },
-            }, {
-                pass: true,
-                youSure: false,
-            });
-            const values = instance.getValues();
-            assert.isExactType(true);
-        });
-    }
-}
-__decorate([
-    test()
-], CreatingEntityInstancesTest, "canCreateStaticEntity", null);
-__decorate([
-    test()
-], CreatingEntityInstancesTest, "typesStaticEntity", null);
-__decorate([
-    test()
-], CreatingEntityInstancesTest, "canCreateDynamicEntity", null);
-__decorate([
-    test()
-], CreatingEntityInstancesTest, "typesDynamicEntity", null);

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

@@ -1,5 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class DroppingFieldsTest extends AbstractSchemaTest {
-    protected static droppingFields(): Promise<void>;
-    protected static droppingPrivateFields(): Promise<void>;
-}