ngx-material-entity 0.1.0

package/esm2020/classes/entity-service.class.mjs

@@ -0,0 +1,70 @@
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { isNil, omit, omitBy } from 'lodash';
+import { EntityUtilities } from './entity-utilities.class';
+/**
+ * A generic EntityService class.
+ * Offers basic CRUD-functionality.
+ * You should create a service for every Entity you have.
+ * If you extend from this you need to make sure that the extended Service can be injected.
+ */
+export class EntityService {
+    constructor(http) {
+        this.http = http;
+        /**
+         * a subject of all the entity values.
+         * Can be subscribed to when you want to do a specific thing whenever the entities change.
+         */
+        this.entitiesSubject = new BehaviorSubject([]);
+    }
+    /**
+     * gets the entities in an array from the internal entitiesSubject
+     */
+    get entities() {
+        return this.entitiesSubject.value;
+    }
+    /**
+     * Creates a new Entity and pushes it to the entities array
+     * @param entity The data of the entity to create.
+     * All values that should be omitted will be removed from it inside this method.
+     * @returns A Promise of the created entity
+     */
+    async create(entity) {
+        const body = omit(entity, EntityUtilities.getOmitForCreate(entity));
+        const e = await firstValueFrom(this.http.post(this.baseUrl, body));
+        this.entities.push(e);
+        this.entitiesSubject.next(this.entities);
+        return e;
+    }
+    /**
+     * Gets all existing entities and pushes them to the entites array
+     * @returns A Promise of all received Entities
+     */
+    async read() {
+        const e = await firstValueFrom(this.http.get(this.baseUrl));
+        this.entitiesSubject.next(e);
+        return e;
+    }
+    /**
+     * Updates a specific Entity
+     * @param entity The updated Entity
+     * All values that should be omitted will be removed from it inside this method.
+     * @param entityPriorChanges The current Entity.
+     * It Is used to get changed values and only update them instead of sending the whole entity data
+     */
+    async update(entity, entityPriorChanges) {
+        const reqBody = omit(EntityUtilities.difference(entity, entityPriorChanges), EntityUtilities.getOmitForUpdate(entity));
+        const updatedEntity = await firstValueFrom(this.http.patch(`${this.baseUrl}/${entityPriorChanges.id}`, omitBy(reqBody, isNil)));
+        this.entities[this.entities.findIndex((e) => e.id === entityPriorChanges.id)] = updatedEntity;
+        this.entitiesSubject.next(this.entities);
+    }
+    /**
+     * Method to delete a specific Entity
+     * @param id The id of the element to delete
+     */
+    async delete(id) {
+        await firstValueFrom(this.http.delete(`${this.baseUrl}/${id}`));
+        this.entities.splice(this.entities.findIndex((e) => e.id === id), 1);
+        this.entitiesSubject.next(this.entities);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/classes/entity-utilities.class.mjs

@@ -0,0 +1,296 @@
+var _a;
+import { isEqual } from 'lodash';
+import { DecoratorTypes } from '../decorators/base/decorator-types.enum';
+/**
+ * Contains HelperMethods around handling Entities and their property-metadata
+ */
+export class EntityUtilities {
+    /**
+     * Gets the properties to omit when updating the entity
+     * @returns The properties which should be left out for updating a new Entity
+     */
+    static getOmitForUpdate(entity) {
+        const res = [];
+        for (const key of Reflect.ownKeys(entity)) {
+            const metadata = Reflect.getMetadata('metadata', entity, key);
+            if (metadata.omitForUpdate) {
+                res.push(key);
+            }
+        }
+        return res;
+    }
+    /**
+     * Gets the properties to omit when creating new entities
+     * @returns The properties which should be left out for creating a new Entity
+     */
+    static getOmitForCreate(entity) {
+        const res = [];
+        for (const key of Reflect.ownKeys(entity)) {
+            const metadata = Reflect.getMetadata('metadata', entity, key);
+            if (metadata.omitForCreate) {
+                res.push(key);
+            }
+        }
+        return res;
+    }
+    /**
+     * Gets the metadata included in an property
+     * @param entity The entity with the property to get the metadata from
+     * @param propertyKey The property on the given Entity to get the metadata from
+     * @param type For secure Typing, defines the returned PropertyConfig
+     * @returns The metadata of the property
+     */
+    static getPropertyMetadata(entity, propertyKey, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    type) {
+        try {
+            const metadata = Reflect.getMetadata('metadata', entity, propertyKey);
+            if (!metadata) {
+                throw new Error(`Could not find metadata for property ${String(propertyKey)}
+                    on the entity ${JSON.stringify(entity)}`);
+            }
+            return metadata;
+        }
+        catch (error) {
+            throw new Error(`Could not find metadata for property ${String(propertyKey)}
+                on the entity ${JSON.stringify(entity)}`);
+        }
+    }
+    /**
+     * Gets the type of the property-metadata.
+     * @param entity The entity with the property to get the type from
+     * @param propertyKey The property on the given Entity to get the type from
+     * @returns The type of the metadata
+     */
+    static getPropertyType(entity, propertyKey) {
+        try {
+            const propertyType = Reflect.getMetadata('type', entity, propertyKey);
+            if (!propertyType) {
+                throw new Error(`Could not find type metadata for property ${String(propertyKey)}
+                    on the entity ${JSON.stringify(entity)}`);
+            }
+            return propertyType;
+        }
+        catch (error) {
+            throw new Error(`Could not find type metadata for property ${String(propertyKey)}
+                on the entity ${JSON.stringify(entity)}`);
+        }
+    }
+    /**
+     * Sets all property values based on a given entity data-object.
+     * @param entity The data object to get the property values from.
+     * @param target
+     * the target object that needs to be constructed
+     * (if called inside a Entity constructor its usually this)
+     * @alias new
+     * @alias build
+     * @alias construct
+     */
+    static new(target, entity) {
+        if (entity) {
+            for (const key in entity) {
+                Reflect.set(target, key, Reflect.get(entity, key));
+            }
+        }
+    }
+    /**
+     * Checks if the values on an entity are valid.
+     * Also checks all the validators given by the metadata ("required", "maxLength" etc.)
+     * @param entity The entity to validate.
+     * @param omit Whether to check for creatiung or editing validity
+     * @returns Whether or not the entity is valid.
+     */
+    static isEntityValid(entity, omit) {
+        for (const key in entity) {
+            if (!this.isPropertyValid(entity, key, omit)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if a single property value is valid
+     * @param entity The entity where the property is from
+     * @param key The name of the property
+     * @returns Whether or not the property value is valid
+     */
+    static isPropertyValid(entity, key, omit) {
+        const type = this.getPropertyType(entity, key);
+        const metadata = this.getPropertyMetadata(entity, key, type);
+        const metadataDefaultString = metadata;
+        const metadataTextboxString = metadata;
+        const metadataAutocompleteString = metadata;
+        const metadataDefaultNumber = metadata;
+        const objectProperty = entity[key];
+        const metadataEntityArray = metadata;
+        const arrayItems = entity[key];
+        if (metadata.omitForCreate && omit === 'create') {
+            return true;
+        }
+        if (metadata.omitForUpdate && omit === 'edit') {
+            return true;
+        }
+        if (metadata.required && !entity[key]) {
+            return false;
+        }
+        switch (type) {
+            case DecoratorTypes.STRING:
+                if (metadataDefaultString.maxLength
+                    && entity[key].length > metadataDefaultString.maxLength) {
+                    return false;
+                }
+                if (metadataDefaultString.minLength
+                    && entity[key].length < metadataDefaultString.minLength) {
+                    return false;
+                }
+                if (metadataDefaultString.regex
+                    && !entity[key].match(metadataDefaultString.regex)) {
+                    return false;
+                }
+                break;
+            case DecoratorTypes.STRING_AUTOCOMPLETE:
+                if (metadataAutocompleteString.maxLength
+                    && entity[key].length > metadataAutocompleteString.maxLength) {
+                    return false;
+                }
+                if (metadataAutocompleteString.minLength
+                    && entity[key].length < metadataAutocompleteString.minLength) {
+                    return false;
+                }
+                if (metadataAutocompleteString.regex
+                    && entity[key].match(metadataAutocompleteString.regex)) {
+                    return false;
+                }
+                break;
+            case DecoratorTypes.STRING_TEXTBOX:
+                if (metadataTextboxString.maxLength
+                    && entity[key].length > metadataTextboxString.maxLength) {
+                    return false;
+                }
+                if (metadataTextboxString.minLength
+                    && entity[key].length < metadataTextboxString.minLength) {
+                    return false;
+                }
+                break;
+            case DecoratorTypes.NUMBER:
+                if (metadataDefaultNumber.max && entity[key] > metadataDefaultNumber.max) {
+                    return false;
+                }
+                if (metadataDefaultNumber.min && entity[key] > metadataDefaultNumber.min) {
+                    return false;
+                }
+                break;
+            case DecoratorTypes.OBJECT:
+                for (const parameterKey in objectProperty) {
+                    if (!this.isPropertyValid(objectProperty, parameterKey, omit)) {
+                        return false;
+                    }
+                }
+                break;
+            case DecoratorTypes.ARRAY_STRING_CHIPS:
+            case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS:
+            case DecoratorTypes.ARRAY:
+                if (metadataEntityArray.required && !arrayItems.length) {
+                    return false;
+                }
+                break;
+            default:
+                throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);
+        }
+        return true;
+    }
+    /**
+     * Checks if an entity is "dirty" (if its values have changed)
+     * @param entity The entity after all changes
+     * @param entityPriorChanges The entity before the changes
+     * @returns Whether or not the entity is dirty
+     */
+    static dirty(entity, entityPriorChanges) {
+        if (!entityPriorChanges) {
+            return false;
+        }
+        else {
+            const diff = this.difference(entity, entityPriorChanges);
+            if (JSON.stringify(diff) === '{}') {
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+    }
+    /**
+     * Compares two Entities and returns their difference in an object
+     * @param entity The first entity to compare
+     * @param entityPriorChanges The second entity to compare
+     * @returns The difference between the two Entities in form of a Partial
+     */
+    static difference(entity, entityPriorChanges) {
+        const res = {};
+        for (const key in entity) {
+            if (!isEqual(entity[key], entityPriorChanges[key])) {
+                res[key] = entity[key];
+            }
+        }
+        return res;
+    }
+    /**
+     * compare function for sorting entity keys by their order value
+     * @param a first key of entity
+     * @param b second key of entity
+     * @param entity current entity (used to get metadata of entity keys)
+     */
+    static compareOrder(a, b, entity) {
+        const metadataA = EntityUtilities.getPropertyMetadata(entity, a, EntityUtilities.getPropertyType(entity, a));
+        const metadataB = EntityUtilities.getPropertyMetadata(entity, b, EntityUtilities.getPropertyType(entity, b));
+        if (metadataA.order === -1) {
+            return 1;
+        }
+        else if (metadataB.order === -1) {
+            return 0;
+        }
+        return (metadataA.order - metadataB.order);
+    }
+    /**
+     * gets the bootstrap column values for "lg", "md", "sm"
+     * @param entity entity to get the bootstrap column values of the key
+     * @param key key of the property to get bootstrap column values from
+     * @param type defines for which screensize the column values should be returned
+     * @returns bootstrap column value
+     */
+    static getWidth(entity, key, type) {
+        const propertyType = EntityUtilities.getPropertyType(entity, key);
+        const metadata = EntityUtilities.getPropertyMetadata(entity, key, propertyType);
+        if (metadata.defaultWidths) {
+            switch (type) {
+                case 'lg':
+                    return metadata.defaultWidths[0];
+                case 'md':
+                    return metadata.defaultWidths[1];
+                case 'sm':
+                    return metadata.defaultWidths[2];
+                default:
+                    throw new Error('Something went wrong getting the width');
+            }
+        }
+        else {
+            throw new Error('Something went wrong getting the width');
+        }
+    }
+    /**
+     * Resets all changes on an entity
+     * @param entity The entity to reset
+     * @param entityPriorChanges The entity before any changes
+     */
+    static resetChangesOnEntity(entity, entityPriorChanges) {
+        for (const key in entityPriorChanges) {
+            Reflect.set(entity, key, Reflect.get(entityPriorChanges, key));
+        }
+    }
+}
+_a = EntityUtilities;
+// eslint-disable-next-line @typescript-eslint/member-ordering
+EntityUtilities.construct = _a.new;
+// eslint-disable-next-line @typescript-eslint/member-ordering
+EntityUtilities.build = _a.new;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-utilities.class.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/classes/entity-utilities.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { isEqual } from 'lodash';\nimport { DecoratorType, DecoratorTypes } from '../decorators/base/decorator-types.enum';\nimport { PropertyDecoratorConfig } from '../decorators/base/property-decorator-config.interface';\nimport { DefaultNumberDecoratorConfig } from '../decorators/number.decorator';\nimport { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, TextboxStringDecoratorConfig } from '../decorators/string.decorator';\nimport { EntityArrayDecoratorConfig } from '../decorators/array.decorator';\nimport { Entity } from './entity-model.class';\n\n/**\n * Contains HelperMethods around handling Entities and their property-metadata\n */\nexport abstract class EntityUtilities {\n    /**\n     * Gets the properties to omit when updating the entity\n     * @returns The properties which should be left out for updating a new Entity\n     */\n    static getOmitForUpdate<EntityType extends Entity>(entity: EntityType): (keyof EntityType)[] {\n        const res: (keyof EntityType)[] = [];\n        for (const key of Reflect.ownKeys(entity)) {\n            const metadata = Reflect.getMetadata('metadata', entity, key) as PropertyDecoratorConfig;\n            if (metadata.omitForUpdate) {\n                res.push(key as keyof EntityType);\n            }\n        }\n        return res;\n    }\n\n    /**\n     * Gets the properties to omit when creating new entities\n     * @returns The properties which should be left out for creating a new Entity\n     */\n    static getOmitForCreate<EntityType extends Entity>(entity: EntityType): (keyof EntityType)[] {\n        const res: (keyof EntityType)[] = [];\n        for (const key of Reflect.ownKeys(entity)) {\n            const metadata = Reflect.getMetadata('metadata', entity, key) as PropertyDecoratorConfig;\n            if (metadata.omitForCreate) {\n                res.push(key as keyof EntityType);\n            }\n        }\n        return res;\n    }\n\n    /**\n     * Gets the metadata included in an property\n     * @param entity The entity with the property to get the metadata from\n     * @param propertyKey The property on the given Entity to get the metadata from\n     * @param type For secure Typing, defines the returned PropertyConfig\n     * @returns The metadata of the property\n     */\n    static getPropertyMetadata<EntityType extends Entity, T extends DecoratorTypes>(\n        entity: EntityType,\n        propertyKey: keyof EntityType,\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        type: T\n    ): DecoratorType<T> {\n        try {\n            const metadata = Reflect.getMetadata('metadata', entity, propertyKey as string) as DecoratorType<T>;\n            if (!metadata) {\n                throw new Error(\n                    `Could not find metadata for property ${String(propertyKey)}\n                    on the entity ${JSON.stringify(entity)}`\n                );\n            }\n            return metadata ;\n        }\n        catch (error) {\n            throw new Error(\n                `Could not find metadata for property ${String(propertyKey)}\n                on the entity ${JSON.stringify(entity)}`\n            );\n        }\n    }\n\n    /**\n     * Gets the type of the property-metadata.\n     * @param entity The entity with the property to get the type from\n     * @param propertyKey The property on the given Entity to get the type from\n     * @returns The type of the metadata\n     */\n    static getPropertyType<EntityType extends Entity>(\n        entity: EntityType, propertyKey: keyof EntityType\n    ): DecoratorTypes {\n        try {\n            const propertyType = Reflect.getMetadata('type', entity, propertyKey as string) as DecoratorTypes;\n            if (!propertyType) {\n                throw new Error(\n                    `Could not find type metadata for property ${String(propertyKey)}\n                    on the entity ${JSON.stringify(entity)}`\n                );\n            }\n            return propertyType;\n        }\n        catch (error) {\n            throw new Error(\n                `Could not find type metadata for property ${String(propertyKey)}\n                on the entity ${JSON.stringify(entity)}`\n            );\n        }\n    }\n\n    /**\n     * Sets all property values based on a given entity data-object.\n     * @param entity The data object to get the property values from.\n     * @param target\n     * the target object that needs to be constructed\n     * (if called inside a Entity constructor its usually this)\n     * @alias new\n     * @alias build\n     * @alias construct\n     */\n    static new<EntityType extends Entity>(target: EntityType, entity?: EntityType): void {\n        if (entity) {\n            for (const key in entity) {\n                Reflect.set(target, key, Reflect.get(entity, key));\n            }\n        }\n    }\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n    static construct = this.new;\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n    static build = this.new;\n\n    /**\n     * Checks if the values on an entity are valid.\n     * Also checks all the validators given by the metadata (\"required\", \"maxLength\" etc.)\n     * @param entity The entity to validate.\n     * @param omit Whether to check for creatiung or editing validity\n     * @returns Whether or not the entity is valid.\n     */\n    static isEntityValid<EntityType extends Entity>(entity: EntityType, omit: 'create' | 'edit'): boolean {\n        for (const key in entity) {\n            if (!this.isPropertyValid(entity, key, omit)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Checks if a single property value is valid\n     * @param entity The entity where the property is from\n     * @param key The name of the property\n     * @returns Whether or not the property value is valid\n     */\n    private static isPropertyValid<EntityType extends Entity>(entity: EntityType, key: keyof EntityType, omit: 'create' | 'edit'): boolean {\n        const type = this.getPropertyType(entity, key);\n        const metadata: PropertyDecoratorConfig = this.getPropertyMetadata(entity, key, type);\n        const metadataDefaultString = metadata as DefaultStringDecoratorConfig;\n        const metadataTextboxString = metadata as TextboxStringDecoratorConfig;\n        const metadataAutocompleteString = metadata as AutocompleteStringDecoratorConfig;\n        const metadataDefaultNumber = metadata as DefaultNumberDecoratorConfig;\n        const objectProperty = entity[key] as unknown as EntityType;\n        const metadataEntityArray = metadata as EntityArrayDecoratorConfig<Entity>;\n        const arrayItems = entity[key] as unknown as [];\n\n        if (metadata.omitForCreate && omit === 'create') {\n            return true;\n        }\n        if (metadata.omitForUpdate && omit === 'edit') {\n            return true;\n        }\n        if (metadata.required && !entity[key]) {\n            return false;\n        }\n        switch (type) {\n            case DecoratorTypes.STRING:\n                if (\n                    metadataDefaultString.maxLength\n                    && (entity[key] as unknown as string).length > metadataDefaultString.maxLength\n                ) {\n                    return false;\n                }\n                if (\n                    metadataDefaultString.minLength\n                    && (entity[key] as unknown as string).length < metadataDefaultString.minLength\n                ) {\n                    return false;\n                }\n                if (\n                    metadataDefaultString.regex\n                    && !(entity[key] as unknown as string).match(metadataDefaultString.regex)\n                ) {\n                    return false;\n                }\n                break;\n            case DecoratorTypes.STRING_AUTOCOMPLETE:\n                if (\n                    metadataAutocompleteString.maxLength\n                    && (entity[key] as unknown as string).length > metadataAutocompleteString.maxLength\n                ) {\n                    return false;\n                }\n                if (\n                    metadataAutocompleteString.minLength\n                    && (entity[key] as unknown as string).length < metadataAutocompleteString.minLength\n                ) {\n                    return false;\n                }\n                if (\n                    metadataAutocompleteString.regex\n                    && (entity[key] as unknown as string).match(metadataAutocompleteString.regex)\n                ) {\n                    return false;\n                }\n                break;\n            case DecoratorTypes.STRING_TEXTBOX:\n                if (\n                    metadataTextboxString.maxLength\n                    && (entity[key] as unknown as string).length > metadataTextboxString.maxLength\n                ) {\n                    return false;\n                }\n                if (\n                    metadataTextboxString.minLength\n                    && (entity[key] as unknown as string).length < metadataTextboxString.minLength\n                ) {\n                    return false;\n                }\n                break;\n            case DecoratorTypes.NUMBER:\n                if (metadataDefaultNumber.max && (entity[key] as unknown as number) > metadataDefaultNumber.max) {\n                    return false;\n                }\n                if (metadataDefaultNumber.min && (entity[key] as unknown as number) > metadataDefaultNumber.min) {\n                    return false;\n                }\n                break;\n            case DecoratorTypes.OBJECT:\n                for (const parameterKey in objectProperty) {\n                    if (!this.isPropertyValid(objectProperty, parameterKey, omit)) {\n                        return false;\n                    }\n                }\n                break;\n            case DecoratorTypes.ARRAY_STRING_CHIPS:\n            case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS:\n            case DecoratorTypes.ARRAY:\n                if (metadataEntityArray.required && !arrayItems.length) {\n                    return false;\n                }\n                break;\n            default:\n                throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);\n        }\n        return true;\n    }\n\n    /**\n     * Checks if an entity is \"dirty\" (if its values have changed)\n     * @param entity The entity after all changes\n     * @param entityPriorChanges The entity before the changes\n     * @returns Whether or not the entity is dirty\n     */\n    static dirty(entity: Entity, entityPriorChanges: Entity): boolean {\n        if (!entityPriorChanges) {\n            return false;\n        }\n        else {\n            const diff = this.difference(entity, entityPriorChanges);\n            if (JSON.stringify(diff) === '{}') {\n                return false;\n            }\n            else {\n                return true;\n            }\n        }\n    }\n\n    /**\n     * Compares two Entities and returns their difference in an object\n     * @param entity The first entity to compare\n     * @param entityPriorChanges The second entity to compare\n     * @returns The difference between the two Entities in form of a Partial\n     */\n    static difference<EntityType extends Entity>(\n        entity: EntityType,\n        entityPriorChanges: EntityType\n    ): Partial<EntityType> {\n        const res: Partial<EntityType> = {};\n        for (const key in entity) {\n            if (!isEqual(entity[key], entityPriorChanges[key])) {\n                res[key] = entity[key];\n            }\n        }\n        return res;\n    }\n\n    /**\n     * compare function for sorting entity keys by their order value\n     * @param a first key of entity\n     * @param b second key of entity\n     * @param entity current entity (used to get metadata of entity keys)\n     */\n    static compareOrder<EntityType extends Entity>(a: keyof EntityType, b: keyof EntityType, entity: EntityType): number {\n        const metadataA = EntityUtilities.getPropertyMetadata(entity, a, EntityUtilities.getPropertyType(entity, a));\n        const metadataB = EntityUtilities.getPropertyMetadata(entity, b, EntityUtilities.getPropertyType(entity, b));\n\n        if (metadataA.order === -1) {\n            return 1;\n        }\n        else if (metadataB.order === -1) {\n            return 0;\n        }\n\n        return ((metadataA.order as number) - (metadataB.order as number));\n    }\n\n    /**\n     * gets the bootstrap column values for \"lg\", \"md\", \"sm\"\n     * @param entity entity to get the bootstrap column values of the key\n     * @param key key of the property to get bootstrap column values from\n     * @param type defines for which screensize the column values should be returned\n     * @returns bootstrap column value\n     */\n    static getWidth<EntityType extends Entity>(entity: EntityType, key: keyof EntityType, type: 'lg' | 'md' | 'sm'): number {\n        const propertyType = EntityUtilities.getPropertyType(entity, key);\n        const metadata = EntityUtilities.getPropertyMetadata(entity, key, propertyType);\n        if (metadata.defaultWidths) {\n            switch (type) {\n                case 'lg':\n                    return metadata.defaultWidths[0];\n                case 'md':\n                    return metadata.defaultWidths[1];\n                case 'sm':\n                    return metadata.defaultWidths[2];\n                default:\n                    throw new Error('Something went wrong getting the width');\n            }\n        }\n        else {\n            throw new Error('Something went wrong getting the width');\n        }\n    }\n\n    /**\n     * Resets all changes on an entity\n     * @param entity The entity to reset\n     * @param entityPriorChanges The entity before any changes\n     */\n    static resetChangesOnEntity<EntityType extends Entity>(entity: EntityType, entityPriorChanges: EntityType): void {\n        for (const key in entityPriorChanges) {\n            Reflect.set(entity, key, Reflect.get(entityPriorChanges, key));\n        }\n    }\n}"]}

package/esm2020/components/confirm-dialog/confirm-dialog-data.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/confirm-dialog/confirm-dialog.component.mjs

@@ -0,0 +1,51 @@
+import { Component, Inject } from '@angular/core';
+import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/checkbox";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+export class NgxMatEntityConfirmDialogComponent {
+    constructor(dialogRef, data) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        /**
+         * Used for the checkbox to confirm the action
+         */
+        this.confirm = false;
+    }
+    ngOnInit() {
+        if (this.data.requireConfirmation && !this.data.confirmationText) {
+            throw new Error(`
+                Missing required Input "confirmationText".
+                You can only omit this if you dont have "requireConfirmation" set`);
+        }
+        if (!this.data.requireConfirmation && this.data.confirmationText) {
+            throw new Error('The "confirmationText" will never be shown because "requireConfirmation" is not set to true');
+        }
+        if (this.data.requireConfirmation !== true && this.data.requireConfirmation !== false) {
+            this.data.requireConfirmation = false;
+        }
+        if (this.data.type === 'info-only' && this.data.cancelButtonLabel) {
+            throw new Error('The "cancelButtonLabel" will never be shown because "type" is set to "info-only"');
+        }
+        this.dialogRef.disableClose = true;
+    }
+    confirmAction() {
+        this.dialogRef.close(1);
+    }
+    cancel() {
+        this.dialogRef.close();
+    }
+}
+NgxMatEntityConfirmDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+NgxMatEntityConfirmDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NgxMatEntityConfirmDialogComponent, selector: "ngx-mat-entity-confirm-dialog", ngImport: i0, template: "<h2 mat-dialog-title *ngIf=\"data.title\">{{data.title}}</h2>\n\n<mat-dialog-content>\n    <p *ngFor=\"let paragraph of data.text\">{{paragraph}}</p>\n    <div *ngIf=\"data.requireConfirmation\" class=\"checkbox-wrapper\">\n        <mat-checkbox [(ngModel)]=\"confirm\" name=\"confirm\">\n            {{data.confirmationText}}\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <button *ngIf=\"data.type === 'delete'\" mat-raised-button color=\"warn\" (click)=\"confirmAction()\" [disabled]=\"data.requireConfirmation && !confirm\" class=\"confirm-button\">\n        {{data.confirmButtonLabel ? data.confirmButtonLabel : 'Delete'}}\n    </button>\n    <button *ngIf=\"data.type !== 'delete'\" mat-raised-button (click)=\"confirmAction()\" [disabled]=\"data.requireConfirmation && !confirm\" class=\"confirm-button\">\n        {{data.confirmButtonLabel ? data.confirmButtonLabel : data.type === 'info-only' ? 'Ok' : 'Confirm'}}\n    </button>\n    <button mat-raised-button (click)=\"cancel()\" class=\"cancel-button\">\n        {{data.cancelButtonLabel ? data.cancelButtonLabel : 'Cancel'}}\n    </button>\n</mat-dialog-actions>\n", styles: [".checkbox-wrapper{min-height:50px;display:flex}.checkbox-wrapper>mat-checkbox{align-self:center}mat-dialog-actions{display:flex;justify-content:space-between}\n"], components: [{ type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-mat-entity-confirm-dialog', template: "<h2 mat-dialog-title *ngIf=\"data.title\">{{data.title}}</h2>\n\n<mat-dialog-content>\n    <p *ngFor=\"let paragraph of data.text\">{{paragraph}}</p>\n    <div *ngIf=\"data.requireConfirmation\" class=\"checkbox-wrapper\">\n        <mat-checkbox [(ngModel)]=\"confirm\" name=\"confirm\">\n            {{data.confirmationText}}\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <button *ngIf=\"data.type === 'delete'\" mat-raised-button color=\"warn\" (click)=\"confirmAction()\" [disabled]=\"data.requireConfirmation && !confirm\" class=\"confirm-button\">\n        {{data.confirmButtonLabel ? data.confirmButtonLabel : 'Delete'}}\n    </button>\n    <button *ngIf=\"data.type !== 'delete'\" mat-raised-button (click)=\"confirmAction()\" [disabled]=\"data.requireConfirmation && !confirm\" class=\"confirm-button\">\n        {{data.confirmButtonLabel ? data.confirmButtonLabel : data.type === 'info-only' ? 'Ok' : 'Confirm'}}\n    </button>\n    <button mat-raised-button (click)=\"cancel()\" class=\"cancel-button\">\n        {{data.cancelButtonLabel ? data.cancelButtonLabel : 'Cancel'}}\n    </button>\n</mat-dialog-actions>\n", styles: [".checkbox-wrapper{min-height:50px;display:flex}.checkbox-wrapper>mat-checkbox{align-self:center}mat-dialog-actions{display:flex;justify-content:space-between}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/confirm-dialog/confirm-dialog.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatDialogModule } from '@angular/material/dialog';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { NgxMatEntityConfirmDialogComponent } from './confirm-dialog.component';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import * as i0 from "@angular/core";
+export class NgxMatEntityConfirmDialogModule {
+}
+NgxMatEntityConfirmDialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxMatEntityConfirmDialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogModule, declarations: [NgxMatEntityConfirmDialogComponent], imports: [CommonModule, MatDialogModule, FormsModule, MatCheckboxModule, MatButtonModule], exports: [NgxMatEntityConfirmDialogComponent] });
+NgxMatEntityConfirmDialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogModule, imports: [[CommonModule, MatDialogModule, FormsModule, MatCheckboxModule, MatButtonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgxMatEntityConfirmDialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NgxMatEntityConfirmDialogComponent],
+                    imports: [CommonModule, MatDialogModule, FormsModule, MatCheckboxModule, MatButtonModule],
+                    exports: [NgxMatEntityConfirmDialogComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/get-validation-error-message.function.mjs

@@ -0,0 +1,32 @@
+/**
+ * Generates a default error message for most validation errors.
+ * @param model The ngModel to get the error from
+ * @returns The Validation Error Message to display
+ */
+export function getValidationErrorMessage(model) {
+    if (model.hasError('matDatepickerParse')) {
+        return 'not a valid date';
+    }
+    else if (model.hasError('email')) {
+        return 'not a valid email';
+    }
+    else if (model.hasError('minlength')) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return `needs to be at least ${model.getError('minlength').requiredLength} characters long`;
+    }
+    else if (model.hasError('min')) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return `needs to be equal or bigger than ${model.getError('min').min}`;
+    }
+    else if (model.hasError('max')) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return `needs to be equal or smaller than ${model.getError('max').max}`;
+    }
+    else if (model.hasError('required')) {
+        return 'required';
+    }
+    else {
+        return 'invalid input';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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