ngx-material-entity 0.1.3 → 1.0.0

package/decorators/file/file-decorator.data.d.ts

@@ -0,0 +1,92 @@
+import { ConfirmDialogData } from '../../components/confirm-dialog/confirm-dialog-data';
+import { PropertyDecoratorConfig } from '../base/property-decorator.data';
+import { FileDataWithFile, FileDataWithUrl } from './file-decorator-internal.data';
+/**
+ * The type of a property annotated with @file.
+ */
+export declare type FileData = FileDataWithFile | FileDataWithUrl;
+/**
+ * Definition for the @file metadata.
+ */
+declare abstract class FileDecoratorConfig extends PropertyDecoratorConfig {
+    /**
+     * Specifies whether or not the decorated property can have multiple files.
+     */
+    multiple: boolean;
+    /**
+     * The type of the upload.
+     */
+    type: 'image' | 'other';
+    /**
+     * The class for the <i> tag used to remove a file from the input.
+     *
+     * @default 'fas fa-circle-minus'
+     */
+    deleteIcon?: string;
+    /**
+     * Whether or not the file should be displayed inside a preview.
+     *
+     * @default true
+     */
+    preview?: boolean;
+    /**
+     * Specifies allowed File types like 'image/jpg' etc.
+     * Allows every file type if not set.
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * The error dialog to display when the user inputs files that are not of the allowed mime types.
+     */
+    mimeTypeErrorDialog?: ConfirmDialogData;
+    /**
+     * The maximum allowed size of a single file in MB.
+     *
+     * @default 10
+     */
+    maxSize?: number;
+    /**
+     * The error dialog to display when the user inputs a single file that is bigger than the 'maxSize' value.
+     */
+    maxSizeErrorDialog?: ConfirmDialogData;
+    /**
+     * The maximum allowed size of all files in MB.
+     *
+     * @default 100
+     */
+    maxSizeTotal?: number;
+    /**
+     * The error dialog to display when the user inputs files which are in total bigger than the 'maxSizeTotal' value.
+     */
+    maxSizeTotalErrorDialog?: ConfirmDialogData;
+    /**
+     * Defines whether or not a dropdown box is displayed.
+     *
+     * @default true // when multiple is set to true.
+     * false // when multiple is set to false.
+     */
+    dragAndDrop?: boolean;
+}
+/**
+ * Definition for a default file.
+ */
+export interface DefaultFileDecoratorConfig extends FileDecoratorConfig {
+    type: 'other';
+    preview?: false;
+}
+/**
+ * Definition for a image file.
+ */
+export interface ImageFileDecoratorConfig extends FileDecoratorConfig {
+    type: 'image';
+    /**
+     * Specifies allowed File types like image/jpg etc. In a comma separated string.
+     *
+     * @default ['image/*']
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Url to the file that gets displayed in the preview when no file has been selected yet.
+     */
+    previewPlaceholderUrl?: string;
+}
+export {};

package/decorators/file/file.decorator.d.ts

@@ -0,0 +1,9 @@
+import { DefaultFileDecoratorConfig, ImageFileDecoratorConfig } from './file-decorator.data';
+/**
+ * Decorator for setting and getting file property metadata.
+ *
+ * @param metadata - The metadata of the file property.
+ * @returns The method that defines the metadata.
+ * @throws When an unknown metadata type was provided.
+ */
+export declare function file(metadata: DefaultFileDecoratorConfig | ImageFileDecoratorConfig): (target: object, propertyKey: string) => void;

package/decorators/number/number-decorator-internal.data.d.ts

@@ -1,3 +1,4 @@
+import { DropdownValue } from '../base/dropdown-value.interface';
 import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
 import { DefaultNumberDecoratorConfig, DropdownNumberDecoratorConfig } from './number-decorator.data';
 /**
@@ -14,9 +15,6 @@ export declare class DefaultNumberDecoratorConfigInternal extends PropertyDecora
  */
 export declare class DropdownNumberDecoratorConfigInternal extends PropertyDecoratorConfigInternal implements DropdownNumberDecoratorConfig {
     displayStyle: 'dropdown';
-    dropdownValues: {
-        displayName: string;
-        value: number;
-    }[];
+    dropdownValues: DropdownValue<number>[];
     constructor(data: DropdownNumberDecoratorConfig);
 }

package/decorators/number/number-decorator.data.d.ts

@@ -1,3 +1,4 @@
+import { DropdownValue } from '../base/dropdown-value.interface';
 import { PropertyDecoratorConfig } from '../base/property-decorator.data';
 /**
  * Definition for the @number metadata.
@@ -30,9 +31,6 @@ export interface DropdownNumberDecoratorConfig extends NumberDecoratorConfig {
     /**
      * The values of the dropdown, consisting of a name to display and the actual value.
      */
-    dropdownValues: {
-        displayName: string;
-        value: number;
-    }[];
+    dropdownValues: DropdownValue<number>[];
 }
 export {};

package/decorators/number/number.decorator.d.ts

@@ -1,8 +1,8 @@
 import { DefaultNumberDecoratorConfig, DropdownNumberDecoratorConfig } from './number-decorator.data';
 /**
- * Decorator for setting and getting string property metadata.
+ * Decorator for setting and getting number property metadata.
  *
- * @param metadata - The metadata of the string property.
+ * @param metadata - The metadata of the number property.
  * @returns The method that defines the metadata.
  */
 export declare function number(metadata: DefaultNumberDecoratorConfig | DropdownNumberDecoratorConfig): (target: object, propertyKey: string) => void;

package/decorators/object/object-decorator-internal.data.d.ts

@@ -1,11 +1,11 @@
-import { Entity } from '../../classes/entity-model.class';
+import { BaseEntityType, EntityClassNewable } from '../../classes/entity.model';
 import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
 import { DefaultObjectDecoratorConfig } from './object-decorator.data';
 /**
  * The internal DefaultObjectDecoratorConfig. Sets default values.
  */
-export declare class DefaultObjectDecoratorConfigInternal<EntityType extends Entity> extends PropertyDecoratorConfigInternal implements DefaultObjectDecoratorConfig<EntityType> {
+export declare class DefaultObjectDecoratorConfigInternal<EntityType extends BaseEntityType<EntityType>> extends PropertyDecoratorConfigInternal implements DefaultObjectDecoratorConfig<EntityType> {
     displayStyle: 'inline';
-    type: new (entity?: EntityType) => EntityType;
+    EntityClass: EntityClassNewable<EntityType>;
     constructor(data: DefaultObjectDecoratorConfig<EntityType>);
 }

package/decorators/object/object-decorator.data.d.ts

@@ -1,13 +1,13 @@
-import { Entity } from '../../classes/entity-model.class';
+import { BaseEntityType, EntityClassNewable } from '../../classes/entity.model';
 import { PropertyDecoratorConfig } from '../base/property-decorator.data';
 /**
  * Definition for the @object metadata.
  */
-declare abstract class ObjectDecoratorConfig<EntityType extends Entity> extends PropertyDecoratorConfig {
+declare abstract class ObjectDecoratorConfig<EntityType extends BaseEntityType<EntityType>> extends PropertyDecoratorConfig {
     /**
-     * The entity type of the object.
+     * The class of the object. Is used to call the constructor so that all metadata is initialized.
      */
-    type: new (entity?: EntityType) => EntityType;
+    EntityClass: EntityClassNewable<EntityType>;
     /**
      * How to display the object.
      *
@@ -19,7 +19,7 @@ declare abstract class ObjectDecoratorConfig<EntityType extends Entity> extends
 /**
  * The configuration options for a object property.
  */
-export interface DefaultObjectDecoratorConfig<EntityType extends Entity> extends ObjectDecoratorConfig<EntityType> {
+export interface DefaultObjectDecoratorConfig<EntityType extends BaseEntityType<EntityType>> extends ObjectDecoratorConfig<EntityType> {
     displayStyle: 'inline';
 }
 export {};

package/decorators/object/object.decorator.d.ts

@@ -1,9 +1,9 @@
-import { Entity } from '../../classes/entity-model.class';
 import { DefaultObjectDecoratorConfig } from './object-decorator.data';
+import { BaseEntityType } from '../../classes/entity.model';
 /**
  * Decorator for setting and getting object property metadata.
  *
  * @param metadata - The metadata of the object property.
  * @returns The method that defines the metadata.
  */
-export declare function object<EntityType extends Entity>(metadata: DefaultObjectDecoratorConfig<EntityType>): (target: object, propertyKey: string) => void;
+export declare function object<EntityType extends BaseEntityType<EntityType>>(metadata: DefaultObjectDecoratorConfig<EntityType>): (target: object, propertyKey: string) => void;

package/decorators/string/string-decorator-internal.data.d.ts

@@ -1,3 +1,4 @@
+import { DropdownValue } from '../base/dropdown-value.interface';
 import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
 import { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, DropdownStringDecoratorConfig, TextboxStringDecoratorConfig } from './string-decorator.data';
 /**
@@ -5,10 +6,7 @@ import { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, Dropdo
  */
 export declare class DropdownStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal implements DropdownStringDecoratorConfig {
     displayStyle: 'dropdown';
-    dropdownValues: {
-        displayName: string;
-        value: string;
-    }[];
+    dropdownValues: DropdownValue<string>[];
     constructor(data: DropdownStringDecoratorConfig);
 }
 /**

package/decorators/string/string-decorator.data.d.ts

@@ -1,3 +1,4 @@
+import { DropdownValue } from '../base/dropdown-value.interface';
 import { PropertyDecoratorConfig } from '../base/property-decorator.data';
 /**
  * Definition for the @string metadata.
@@ -17,10 +18,7 @@ export interface DropdownStringDecoratorConfig extends StringDecoratorConfig {
      * The values of the dropdown, consisting of a name to display and the actual value
      * Can also receive a function to determine the values.
      */
-    dropdownValues: {
-        displayName: string;
-        value: string;
-    }[];
+    dropdownValues: DropdownValue<string>[];
 }
 /**
  * The configuration options for a string property displayed in a default text input.

package/esm2020/capsulation/lodash.utilities.mjs

@@ -0,0 +1,75 @@
+import { cloneDeep, isArray, isEqual, isNil, omit, omitBy } from 'lodash';
+/**
+ * Encapsulates all functionality of lodash.
+ */
+export class LodashUtilities {
+    /**
+     * Performs a deep comparison between two values to determine if they are
+     * equivalent.
+     *
+     * **Note:** This method supports comparing arrays, array buffers, booleans,
+     * date objects, error objects, maps, numbers, `Object` objects, regexps,
+     * sets, strings, symbols, and typed arrays. `Object` objects are compared
+     * by their own, not inherited, enumerable properties. Functions and DOM
+     * nodes are **not** supported.
+     *
+     * @param value - The value to compare.
+     * @param other - The other value to compare.
+     * @returns Returns `true` if the values are equivalent, else `false`.
+     */
+    static isEqual(value, other) {
+        return isEqual(value, other);
+    }
+    /**
+     * This method is like _.clone except that it recursively clones value.
+     *
+     * @param value - The value to recursively clone.
+     * @returns Returns the deep cloned value.
+     */
+    static cloneDeep(value) {
+        return cloneDeep(value);
+    }
+    /**
+     * The opposite of `_.pick`; this method creates an object composed of the
+     * own and inherited enumerable properties of `object` that are not omitted.
+     *
+     * @param object - The source object.
+     * @param paths - The property names to omit, specified
+     * individually or in arrays.
+     * @returns Returns the new object.
+     */
+    static omit(object, ...paths) {
+        return omit(object, ...paths);
+    }
+    /**
+     * Checks if `value` is `null` or `undefined`.
+     *
+     * @param value - The value to check.
+     * @returns Returns `true` if `value` is nullish, else `false`.
+     */
+    static isNil(value) {
+        return isNil(value);
+    }
+    /**
+     * The opposite of `_.pickBy`; this method creates an object composed of the
+     * own and inherited enumerable properties of `object` that `predicate`
+     * doesn't return truthy for.
+     *
+     * @param object - The source object.
+     * @param predicate - The function invoked per property.
+     * @returns Returns the new object.
+     */
+    static omitBy(object, predicate) {
+        return omitBy(object, predicate);
+    }
+    /**
+     * Checks if value is classified as an Array object.
+     *
+     * @param value - The value to check.
+     * @returns Returns true if value is correctly classified, else false.
+     */
+    static isArray(value) {
+        return isArray(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/capsulation/reflect.utilities.mjs

@@ -0,0 +1,69 @@
+/**
+ * Encapsulates all functionality of Reflect.
+ */
+export class ReflectUtilities {
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     *
+     * @param metadataKey - A key used to store and retrieve metadata.
+     * @param target - The target object on which the metadata is defined.
+     * @param propertyKey - The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, undefined.
+     */
+    static getMetadata(metadataKey, target, propertyKey) {
+        return Reflect.getMetadata(metadataKey, target, propertyKey);
+    }
+    /**
+     * Returns the string and symbol keys of the own properties of an object. The own properties of an object
+     * are those that are defined directly on that object, and are not inherited from the object's prototype.
+     *
+     * @param target - Object that contains the own properties.
+     * @returns The keys of the given object.
+     */
+    static ownKeys(target) {
+        return Reflect.ownKeys(target);
+    }
+    /**
+     * Gets the property of target, equivalent to `target[propertyKey]`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - The property name.
+     * @returns The property of the target of the given key.
+     */
+    static get(target, propertyKey) {
+        return Reflect.get(target, propertyKey);
+    }
+    /**
+     * Sets the property of target, equivalent to `target[propertyKey] = value`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - The property name.
+     * @param value - The value to set the property to.
+     * @returns If setting the value was successful.
+     */
+    static set(target, propertyKey, value) {
+        return Reflect.set(target, propertyKey, value);
+    }
+    /**
+     * Equivalent to `propertyKey in target`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - Name of the property.
+     * @returns Whether or not the given target has the key.
+     */
+    static has(target, propertyKey) {
+        return Reflect.has(target, propertyKey);
+    }
+    /**
+     * Define a unique metadata entry on the target.
+     *
+     * @param metadataKey - A key used to store and retrieve metadata.
+     * @param metadataValue - A value that contains attached metadata.
+     * @param target - The target object on which to define metadata.
+     * @param propertyKey - The property key for the target.
+     */
+    static defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        Reflect.defineMetadata(metadataKey, metadataValue, target, propertyKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/classes/base.builder.mjs

@@ -0,0 +1,42 @@
+/**
+ * The abstract BaseBuilder class.
+ */
+export class BaseBuilder {
+    constructor(data) {
+        this.validateInput(data);
+        this.inputData = data;
+        this.data = this.generateBaseData(data);
+        return this;
+    }
+    /**
+     * Used to validate the user input in the constructor.
+     *
+     * @param data - The user input.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    validateInput(data) {
+        // By default, no validation is done
+    }
+    /**
+     * Sets the value for the given key if no user value was provided.
+     *
+     * @param key - The key to set the default value for.
+     * @param value - The value to set when nothing was provided.
+     * @returns The Builder.
+     */
+    withDefault(key, value) {
+        if (this.inputData == null || this.inputData[key] == null) {
+            this.data[key] = value;
+        }
+        return this;
+    }
+    /**
+     * Method used to get the final build value after applying all chaining.
+     *
+     * @returns The build value.
+     */
+    getResult() {
+        return this.data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/classes/date.utilities.mjs

@@ -0,0 +1,158 @@
+import { LodashUtilities } from '../capsulation/lodash.utilities';
+const DAY_IN_MS = 1000 * 60 * 60 * 24;
+/**
+ * Contains Helper Functions for handling date properties.
+ */
+export class DateUtilities {
+    /**
+     * Gets the given value as a date value.
+     *
+     * @param value - The value to get as a date.
+     * @returns The given value as a date.
+     */
+    static asDate(value) {
+        return value;
+    }
+    /**
+     * Gets the default times used by the DateTime picker when nothing is specified by the user.
+     *
+     * @param format - The time format. Defaults to 24.
+     * @param minuteSteps - The steps from one time value to the next. Defaults to 30.
+     * @returns Times in the 24 hour format from 0:00 until 23:30 in 30 minute steps.
+     */
+    static getDefaultTimes(format = 24, minuteSteps = 30) {
+        const res = [{ displayName: '-', value: undefined }];
+        for (let hour = 0; hour < 24; hour++) {
+            for (let minute = 0; minute < 60; minute += minuteSteps) {
+                res.push(DateUtilities.getTimeDropdownValue(format, hour, minute));
+            }
+        }
+        return res;
+    }
+    static getTimeDropdownValue(format, hour, minute) {
+        const displayHour = DateUtilities.getFormattedHour(format, LodashUtilities.cloneDeep(hour));
+        const displayMinute = DateUtilities.getFormattedMinute(format, hour, minute);
+        return {
+            displayName: `${displayHour}:${displayMinute}`,
+            value: {
+                hours: hour,
+                minutes: minute
+            }
+        };
+    }
+    static getFormattedHour(format, hour) {
+        if (format === 12 && hour > 12) {
+            hour -= 12;
+        }
+        return hour;
+    }
+    static getFormattedMinute(format, hour, minute) {
+        let res = `${minute}`;
+        if (format === 12) {
+            if (hour > 12) {
+                res = `${minute} PM`;
+            }
+            else {
+                res = `${minute} AM`;
+            }
+        }
+        if (minute.toString().length === 1) {
+            res = '0'.concat(res);
+        }
+        return res;
+    }
+    /**
+     * Gets the Time object from the given date.
+     *
+     * @param value - The date to get the time object from.
+     * @returns The Time object build from the date value.
+     */
+    static getTimeFromDate(value) {
+        if (!value) {
+            return undefined;
+        }
+        else {
+            return {
+                hours: new Date(value).getHours(),
+                minutes: new Date(value).getMinutes()
+            };
+        }
+    }
+    /**
+     * Gets the dates between the two given gates. Does additional filtering based on the provided DateRange metadata.
+     *
+     * @param startDate - The start date.
+     * @param endDate - The end date.
+     * @param filter - The custom filter from the metadata.
+     * @returns All dates between the two provided dates. Includes start and end date.
+     */
+    static getDatesBetween(startDate, endDate, filter) {
+        const res = [];
+        while (startDate.getFullYear() < endDate.getFullYear()
+            || startDate.getMonth() < endDate.getMonth()
+            || startDate.getDate() <= endDate.getDate()) {
+            res.push(new Date(startDate));
+            startDate.setTime(startDate.getTime() + DAY_IN_MS);
+        }
+        if (filter) {
+            return res.filter(d => filter(d));
+        }
+        else {
+            return res;
+        }
+    }
+    /**
+     * Get all valid times for the dropdown of a datetime property.
+     *
+     * @param date - The date of the datetime.
+     * @param times - All given times to filter.
+     * @param min - The function that defines the minimum time.
+     * @param max - The function that defines the maximum time.
+     * @param filter - A filter function to do more specific time filtering. This could be e.g. The removal of lunch breaks.
+     * @returns All valid dropdown values for the datetime property.
+     */
+    static getValidTimesForDropdown(date, times, min, max, filter) {
+        if (min) {
+            const minTime = min(date);
+            times = times.filter(t => !t.value
+                || t.value.hours > minTime.hours
+                || (t.value.hours === minTime.hours
+                    && t.value.minutes >= minTime.minutes));
+        }
+        if (max) {
+            const maxTime = max(date);
+            times = times.filter(t => !t.value
+                || t.value.hours < maxTime.hours
+                || (t.value.hours === maxTime.hours
+                    && t.value.minutes <= maxTime.minutes));
+        }
+        if (filter) {
+            times = times.filter(t => !t.value || filter(t.value));
+        }
+        return times;
+    }
+    /**
+     * Checks if the time object has processable hours and minutes properties.
+     * Doesn't check custom validators like min/max from the metadata configuration.
+     *
+     * @param time - The time to check.
+     * @returns Whether or not the time object is unprocessable.
+     */
+    static timeIsUnprocessable(time) {
+        if (!time
+            || time.hours == null
+            || typeof time.hours !== 'number'
+            || Number.isNaN(time.hours)
+            || time.minutes == null
+            || typeof time.minutes !== 'number'
+            || Number.isNaN(time.minutes)) {
+            return true;
+        }
+        return false;
+    }
+}
+/**
+ * The default filter function to user when none was provided by the user.
+ */
+DateUtilities.defaultDateFilter = () => true;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.utilities.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/classes/date.utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { Time } from '@angular/common';\nimport { DateFilterFn } from '@angular/material/datepicker';\nimport { LodashUtilities } from '../capsulation/lodash.utilities';\nimport { DropdownValue } from '../decorators/base/dropdown-value.interface';\n\nconst DAY_IN_MS = 1000 * 60 * 60 * 24;\n\n/**\n * Valid steps from one time value to the next. Needs to be able to divide 60 minutes without remainder.\n */\ntype MinuteSteps = 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30 | 60;\n\n/**\n * Contains Helper Functions for handling date properties.\n */\nexport abstract class DateUtilities {\n\n    /**\n     * The default filter function to user when none was provided by the user.\n     */\n    static defaultDateFilter: DateFilterFn<Date | null | undefined> = (): boolean => true;\n\n    /**\n     * Gets the given value as a date value.\n     *\n     * @param value - The value to get as a date.\n     * @returns The given value as a date.\n     */\n    static asDate(value: unknown): Date {\n        return value as Date;\n    }\n\n    /**\n     * Gets the default times used by the DateTime picker when nothing is specified by the user.\n     *\n     * @param format - The time format. Defaults to 24.\n     * @param minuteSteps - The steps from one time value to the next. Defaults to 30.\n     * @returns Times in the 24 hour format from 0:00 until 23:30 in 30 minute steps.\n     */\n    static getDefaultTimes(format: 12 | 24 = 24, minuteSteps: MinuteSteps = 30): DropdownValue<Time>[] {\n        const res: DropdownValue<Time>[] = [{ displayName: '-', value: undefined as unknown as Time}];\n        for (let hour = 0; hour < 24; hour++) {\n            for (let minute = 0; minute < 60; minute += minuteSteps) {\n                res.push(DateUtilities.getTimeDropdownValue(format, hour, minute));\n            }\n        }\n        return res;\n    }\n\n    private static getTimeDropdownValue(format: 12 | 24, hour: number, minute: number): DropdownValue<Time> {\n        const displayHour: number = DateUtilities.getFormattedHour(format, LodashUtilities.cloneDeep(hour));\n        const displayMinute: string = DateUtilities.getFormattedMinute(format, hour, minute);\n        return {\n            displayName: `${displayHour}:${displayMinute}`,\n            value: {\n                hours: hour,\n                minutes: minute\n            }\n        };\n    }\n\n    private static getFormattedHour(format: 12 | 24, hour: number): number {\n        if (format === 12 && hour > 12) {\n            hour -= 12;\n        }\n        return hour;\n    }\n\n    private static getFormattedMinute(format: 12 | 24, hour: number, minute: number): string {\n        let res = `${minute}`;\n        if (format === 12) {\n            if (hour > 12) {\n                res = `${minute} PM`;\n            }\n            else {\n                res = `${minute} AM`;\n            }\n        }\n        if (minute.toString().length === 1) {\n            res = '0'.concat(res);\n        }\n        return res;\n    }\n\n    /**\n     * Gets the Time object from the given date.\n     *\n     * @param value - The date to get the time object from.\n     * @returns The Time object build from the date value.\n     */\n    static getTimeFromDate(value: Date): Time | undefined {\n        if (!(value as Date | undefined)) {\n            return undefined;\n        }\n        else {\n            return {\n                hours: new Date(value).getHours(),\n                minutes: new Date(value).getMinutes()\n            };\n        }\n    }\n\n    /**\n     * Gets the dates between the two given gates. Does additional filtering based on the provided DateRange metadata.\n     *\n     * @param startDate - The start date.\n     * @param endDate - The end date.\n     * @param filter - The custom filter from the metadata.\n     * @returns All dates between the two provided dates. Includes start and end date.\n     */\n    static getDatesBetween(\n        startDate: Date,\n        endDate: Date,\n        filter?: DateFilterFn<Date>\n    ): Date[] {\n        const res: Date[] = [];\n        while (\n            startDate.getFullYear() < endDate.getFullYear()\n            || startDate.getMonth() < endDate.getMonth()\n            || startDate.getDate() <= endDate.getDate()\n        ) {\n            res.push(new Date(startDate));\n            startDate.setTime(startDate.getTime() + DAY_IN_MS);\n        }\n        if (filter) {\n            return res.filter(d => filter(d));\n        }\n        else {\n            return res;\n        }\n    }\n\n    /**\n     * Get all valid times for the dropdown of a datetime property.\n     *\n     * @param date - The date of the datetime.\n     * @param times - All given times to filter.\n     * @param min - The function that defines the minimum time.\n     * @param max - The function that defines the maximum time.\n     * @param filter - A filter function to do more specific time filtering. This could be e.g. The removal of lunch breaks.\n     * @returns All valid dropdown values for the datetime property.\n     */\n    static getValidTimesForDropdown(\n        date: Date,\n        times: DropdownValue<Time>[],\n        min?: (date?: Date) => Time,\n        max?: (date?: Date) => Time,\n        filter?: ((time: Time) => boolean) | (() => boolean)\n    ): DropdownValue<Time>[] {\n        if (min) {\n            const minTime: Time = min(date);\n            times = times.filter(t =>\n                !(t.value as Time | undefined)\n                || t.value.hours > minTime.hours\n                || (\n                    t.value.hours === minTime.hours\n                    && t.value.minutes >= minTime.minutes\n                )\n            );\n        }\n        if (max) {\n            const maxTime: Time = max(date);\n            times = times.filter(t =>\n                !(t.value as Time | undefined)\n                || t.value.hours < maxTime.hours\n                || (\n                    t.value.hours === maxTime.hours\n                    && t.value.minutes <= maxTime.minutes\n                )\n            );\n        }\n        if (filter) {\n            times = times.filter(t => !(t.value as Time | undefined) || filter(t.value));\n        }\n\n        return times;\n    }\n\n    /**\n     * Checks if the time object has processable hours and minutes properties.\n     * Doesn't check custom validators like min/max from the metadata configuration.\n     *\n     * @param time - The time to check.\n     * @returns Whether or not the time object is unprocessable.\n     */\n    static timeIsUnprocessable(time?: Time): boolean {\n        if (\n            !time\n            || time.hours == null\n            || typeof time.hours !== 'number'\n            || Number.isNaN(time.hours)\n            || time.minutes == null\n            || typeof time.minutes !== 'number'\n            || Number.isNaN(time.minutes)\n        ) {\n            return true;\n        }\n        return false;\n    }\n}"]}