@colijnit/sharedcomponents 1.0.64 → 1.0.65

package/lib/utils/date-utils.d.ts

@@ -1,44 +1,44 @@
-import { Month } from "../enum/month.enum";
-import { Moment } from "moment";
-import { DatePipe } from "@angular/common";
-import { DateRange } from "../model/date-range";
-export declare class DateUtils {
-    static readonly BACKEND_DATE_FORMAT: string;
-    static datePipe: DatePipe;
-    static NowAsString(): string;
-    static ParseDate(date: Date, format?: string): string;
-    static GetWeekNumber(date: Date): number;
-    static GetDaysFromNow(date: Date): number;
-    static StringAsDate(str: string, format?: string): Date;
-    static MomentToDate(time: Moment): Date;
-    static GetCurrentMonth(): Month;
-    static Get12MonthsArrayWithFirstMonthIsCurrentMonth(): Month[];
-    static GetFirstDayOfWeek(date: Date): Date;
-    static GetLastDayOfWeek(date: Date): Date;
-    static GetFirstDayOfMonth(date: Date): Date;
-    static GetLastDayOfMonth(date: Date): Date;
-    static DatesEqual(date1: Date, date2: Date): boolean;
-    static DateRangeEqual(dates1: DateRange, dates2: DateRange): boolean;
-    static AddMinutes(date: Date, minutes: number): Date;
-    static AddDays(date: Date, days: number): Date;
-    static AddMonths(date: Date, months: number): Date;
-    static DetermineDSTBreakpoints(): {
-        start: string;
-        end: string;
-    };
-    private static _ValidDate;
-    /**
-     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).
-     * Returns negative values of the 'from' date is later than in time than the 'to' date.
-     */
-    static GetDayDifference(from: Date, to: Date): number;
-    static IsSameDay(dateOne: Date, dateTwo: Date): boolean;
-    static IsInBetween(date: Date, startDate: Date, endDate: Date, withTime?: boolean): boolean;
-    static IsMonday(date: Date): boolean;
-    static IsSunday(date: Date): boolean;
-    static IsToday(date: Date): boolean;
-    static ParseDateInShortDateFormat(date: Date, locale: string): string;
-    static getFormattedDateRangeString(dateRangeString: string, separator?: string): string;
-    static SetDateOrDateRangeObjectHoursZero(date: Date | DateRange): void;
-    private static _DateToTimeStringWithDateFormat;
-}
+import { Month } from "../enum/month.enum";
+import { Moment } from "moment";
+import { DatePipe } from "@angular/common";
+import { DateRange } from "../model/date-range";
+export declare class DateUtils {
+    static readonly BACKEND_DATE_FORMAT: string;
+    static datePipe: DatePipe;
+    static NowAsString(): string;
+    static ParseDate(date: Date, format?: string): string;
+    static GetWeekNumber(date: Date): number;
+    static GetDaysFromNow(date: Date): number;
+    static StringAsDate(str: string, format?: string): Date;
+    static MomentToDate(time: Moment): Date;
+    static GetCurrentMonth(): Month;
+    static Get12MonthsArrayWithFirstMonthIsCurrentMonth(): Month[];
+    static GetFirstDayOfWeek(date: Date): Date;
+    static GetLastDayOfWeek(date: Date): Date;
+    static GetFirstDayOfMonth(date: Date): Date;
+    static GetLastDayOfMonth(date: Date): Date;
+    static DatesEqual(date1: Date, date2: Date): boolean;
+    static DateRangeEqual(dates1: DateRange, dates2: DateRange): boolean;
+    static AddMinutes(date: Date, minutes: number): Date;
+    static AddDays(date: Date, days: number): Date;
+    static AddMonths(date: Date, months: number): Date;
+    static DetermineDSTBreakpoints(): {
+        start: string;
+        end: string;
+    };
+    private static _ValidDate;
+    /**
+     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).
+     * Returns negative values of the 'from' date is later than in time than the 'to' date.
+     */
+    static GetDayDifference(from: Date, to: Date): number;
+    static IsSameDay(dateOne: Date, dateTwo: Date): boolean;
+    static IsInBetween(date: Date, startDate: Date, endDate: Date, withTime?: boolean): boolean;
+    static IsMonday(date: Date): boolean;
+    static IsSunday(date: Date): boolean;
+    static IsToday(date: Date): boolean;
+    static ParseDateInShortDateFormat(date: Date, locale: string): string;
+    static getFormattedDateRangeString(dateRangeString: string, separator?: string): string;
+    static SetDateOrDateRangeObjectHoursZero(date: Date | DateRange): void;
+    private static _DateToTimeStringWithDateFormat;
+}

package/lib/utils/enum-utils.d.ts

@@ -1,31 +1,31 @@
-import { KeyValuePair } from "../interface/key-value-pair";
-import { CoDomainValue } from "@colijnit/mainapi/build/model/co-domain-value.bo";
-import { DictionaryService } from "../service/dictionary.service";
-export declare class EnumUtils {
-    static StringEnumToArray(clazz: any): string[];
-    /**
-     * Returns a single string representation of given string enum class
-     * @param clazz
-     * @returns {string} eg "input-lov-slideout, financial-customer-group-select" for a given clazz of InputLovSlideoutComponentSelectors
-     */
-    static StringEnumToSingleString(clazz: any): string;
-    static GetNumberEnumValues(numberEnumClass: any): any[];
-    static GetStringEnumValues(stringEnumClass: any): any[];
-    static GetObjValues(numberEnumClass: any): (number | string)[];
-    /**
-     * Returns the enum in object format to make handling easier
-     * Works for Enums with the following format:
-     * foo: 1
-     * bar: 2
-     * etc...
-     * @param enumClass
-     * @returns {Object}
-     */
-    static createObjectFromEnum(enumClass: any): KeyValuePair[];
-    static getStringEnumKeysArray(enumType: object): string[];
-    static buildPromiseDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription?: boolean): Promise<CoDomainValue[]>;
-    static buildDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription?: boolean): CoDomainValue[];
-    static getKeyByValue(enumType: object, enumValue: string): string;
-    private static isNumeral;
-}
-export declare function StringEnumToSingleString(clazz: any): string;
+import { KeyValuePair } from "../interface/key-value-pair";
+import { CoDomainValue } from "@colijnit/mainapi/build/model/co-domain-value.bo";
+import { DictionaryService } from "../service/dictionary.service";
+export declare class EnumUtils {
+    static StringEnumToArray(clazz: any): string[];
+    /**
+     * Returns a single string representation of given string enum class
+     * @param clazz
+     * @returns {string} eg "input-lov-slideout, financial-customer-group-select" for a given clazz of InputLovSlideoutComponentSelectors
+     */
+    static StringEnumToSingleString(clazz: any): string;
+    static GetNumberEnumValues(numberEnumClass: any): any[];
+    static GetStringEnumValues(stringEnumClass: any): any[];
+    static GetObjValues(numberEnumClass: any): (number | string)[];
+    /**
+     * Returns the enum in object format to make handling easier
+     * Works for Enums with the following format:
+     * foo: 1
+     * bar: 2
+     * etc...
+     * @param enumClass
+     * @returns {Object}
+     */
+    static createObjectFromEnum(enumClass: any): KeyValuePair[];
+    static getStringEnumKeysArray(enumType: object): string[];
+    static buildPromiseDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription?: boolean): Promise<CoDomainValue[]>;
+    static buildDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription?: boolean): CoDomainValue[];
+    static getKeyByValue(enumType: object, enumValue: string): string;
+    private static isNumeral;
+}
+export declare function StringEnumToSingleString(clazz: any): string;

package/lib/utils/function/not-nill.function.d.ts

@@ -1 +1 @@
-export declare function notNill(value: any): boolean;
+export declare function notNill(value: any): boolean;

package/lib/utils/is-nill.function.d.ts

@@ -1 +1 @@
-export declare function isNill(value: any): boolean;
+export declare function isNill(value: any): boolean;

package/lib/utils/map-utils.d.ts

@@ -1,16 +1,16 @@
-export declare class MapUtils {
-    /**
-     * Returns the first key from given map, for which the value filter holds true. Basically a reverse Map.get(key) function.
-     * @param map
-     * @param valueFilter For the first value that returns true for this filter functions, its key will be returned.
-     */
-    static FindKeyByValue<K, V>(map: Map<K, V>, valueFilter: (value: V) => boolean): K;
-    /**
-     * Inserts given arrayEntry into given map, under given mapKey. What's special here, is that a NEW map entry is created with an array
-     * containing the single [arrayEntry] item, if no entry yet existed.
-     * @param map
-     * @param mapKey
-     * @param arrayEntry
-     */
-    static InsertArrayItemIntoMap(map: Map<any, any>, mapKey: any, arrayEntry: any): void;
-}
+export declare class MapUtils {
+    /**
+     * Returns the first key from given map, for which the value filter holds true. Basically a reverse Map.get(key) function.
+     * @param map
+     * @param valueFilter For the first value that returns true for this filter functions, its key will be returned.
+     */
+    static FindKeyByValue<K, V>(map: Map<K, V>, valueFilter: (value: V) => boolean): K;
+    /**
+     * Inserts given arrayEntry into given map, under given mapKey. What's special here, is that a NEW map entry is created with an array
+     * containing the single [arrayEntry] item, if no entry yet existed.
+     * @param map
+     * @param mapKey
+     * @param arrayEntry
+     */
+    static InsertArrayItemIntoMap(map: Map<any, any>, mapKey: any, arrayEntry: any): void;
+}

package/lib/utils/number-utils.d.ts

@@ -1,125 +1,125 @@
-import { CheckWithinSteppedBoundsResult } from "./check-within-stepped-bounds-result";
-import { CheckPrecisionAndScaleResult } from "./check-precision-and-scale-result";
-export declare class NumberUtils {
-    static ParseIntNumberInput(arg: any): number;
-    static ParseInt(arg: any): number;
-    static ParseFloatNumberInput(arg: any, decimalPrecision?: number): number;
-    static ParseFloatNumberInputKeepPrecision(arg: any): number;
-    /**
-     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
-     *
-     * @param {any} arg The argument to parse to a float
-     * @param {number} decimalPrecision The number of decimals, or the precision, the parsed return float should have
-     * @returns {number} NaN if not possible, else the parsed float value
-     */
-    static ParseFloat(arg: any, decimalPrecision?: number): number;
-    /**
-     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
-     *
-     * @param arg The argument to parse to a float
-     * @returns {number} The argument as a float with its original decimal precision intact
-     */
-    static ParseFloatKeepPrecision(arg: any): number;
-    /**
-     * Returns the given argument as a number. Returns given defaultValue if conversion of argument was impossible.
-     * @param arg
-     * @param {number} [defaultValue = 0]
-     * @returns {number}
-     */
-    static ParseNumberOrDefault(arg: any, defaultValue?: number): number;
-    static IsInteger(arg: any): boolean;
-    static GetDecimalPlaces(arg: any, maxAnswer?: number): number;
-    static ParseNumberInputOrDefault(numberInput: any, defaultValue?: number): number;
-    static IsNumber(arg: any): boolean;
-    /**
-     * Returns whether given arg is indeed not a number (it's NaN or it has another type than 'number')
-     * Our exact copy of AS Flex'es isNaN(arg) function. Always use this method for copying Flex isNaN(..) occurences into TypeScript.
-     * @param arg
-     * @returns {boolean}
-     * @constructor
-     */
-    static IsNaN(arg: any): boolean;
-    static NaN(number: any, substitute?: number): number;
-    static IsParsableNumber(arg: any): boolean;
-    static IsParsableNumberInput(numberInput: any): boolean;
-    /**
-     * Returns whether given arg is parseable as a number, and whether the lengts of its number parse result is equal to its original length.
-     * I.e. this function returns FALSE with given number-parsable strings, but that have non-numeric appendices, eg '2233ff'. That arg
-     * IS number-parseable, but not a strict 'string number', the latter being what this method actually checks for.
-     */
-    static IsStringNumber(arg: string): boolean;
-    static IsListOfNumbers(arg: string, separator?: string): boolean;
-    static ParseStringNumber(arg: string): number;
-    static ParseStringNumberDefault(arg: string | any, defaultValue?: number): number;
-    /**
-     * Returns a random integer in range [lowerBound .. upperBound], an inclusive range. Returns NaN if not possible.
-     * Given bounds are truncated first, before serving as the true lower- and upper bounds for the random int.
-     */
-    static RandomInt(lowerBoundInt: number, upperBoundInt: number): number;
-    static AddThousandsCommasTo(value: any): string;
-    /**
-     * Function used to check wether a given number is composed of another number, power-of-two wise.
-     * Example usage: NumberUtils.NumIsComposedOf(articleListObject.publication, ArticlePublication.Selector).
-     * This would return whether or not that articleListObject was publicated for selector or not, where articleListObject.publication
-     * was possibly a 'COMPOSITE that was made out of (including)' ArticlePublication.Selector.
-     */
-    static NumIsComposedOfOtherPowTwoNum(bigNrToCheck: number, powTwoNumItShouldBeComposedOf: number): boolean;
-    /**
-     * Returns given nr, or the given default number (default 0) if the nr number was undefined or otherwise not a number.
-     * Same as CoMath.NaN from AS code (used as its substitute in transaction logic)
-     * @param nr
-     * @param defaultNr
-     * @returns {number}
-     */
-    static NrOrDefault(nr: number, defaultNr?: number): number;
-    /**
-     * Returns whether given nrToCheck is within the given precision and scale limits. Precision and scale, here, are Oracle DB terms.
-     * This function can thus be used to check whether the given number is safe to send to the 'database' beforehand, if we know the
-     * precision and scale of the number in the db declaration.
-     *
-     * I.e. A number declared in the Oracle DB as number(5, 2) has a precision of 5 and a scale of 2.
-     *
-     * @param {number} nrToCheck
-     * @param {number} precision The number of significant digits, including possibly negative scale. E.g. 3 in '123' and 5 in '51.123'
-     * @param {number} [scale = 0] The number of significant digits AFTER the decimal point. E.g. 1 in 5432.1 and 3 in 54000.003
-     * @returns {CheckPrecisionAndScaleResult} Whether given nrToCheck is ok for given precision and scale, and if not, the
-     * nearest number that IS ok for those constraints.
-     */
-    static CheckPrecisionAndScale(nrToCheck: number, precision: number, scale?: number): CheckPrecisionAndScaleResult;
-    /**
-     * Returns whether given x is OK within the given min, max and step boundaries, where it should hold that nrToCheck = min + N * step,
-     * with N integer or 0.
-     * @param {number} nrToCheck Number to check whether it's within the given bounds
-     * @param min Inclusive
-     * @param max Inclusive
-     * @param stepSize
-     * @returns {CheckWithinSteppedBounds} Returns remainder of undefined when nrToCheck was OUTSIDE [min, max], else full result object.
-     */
-    static CheckWithinSteppedBounds(nrToCheck: number, min: number, max: number, stepSize?: number): CheckWithinSteppedBoundsResult;
-    /**
-     * Finds the number closest to the originalNumber, that adheres to the given bounds. That is, for which it holds that
-     * nr = min + N * step with N integer or 0.
-     * @param {number} originalNr Find closest answer to this number
-     * @param min Inclusive
-     * @param max Inclusive
-     * @param stepSize
-     * @returns {boolean} The closest OK number for bounds.
-     */
-    static GetNearestNumberWithinSteppedBounds(originalNr: number, min: number, max: number, stepSize?: number): number;
-    /**
-     * Returns the true maximum allowed value for the given "stepped bounds": min, stepSize and max, for which it holds that each allowed
-     * value Y = min + stepSize * N, for any INTEGER or 0 N where it also holds, of course, that Y <= max.
-     * @param min
-     * @param max
-     * @param stepSize
-     */
-    static GetTrueSteppedBoundsMax(min: number, max: number, stepSize?: number): number;
-    static GetNearestNumberWithinBounds(originalNr: number, min: number, max: number): number;
-    static ToString(nr: number): string;
-    static DecimalsToStepIncrement(numberOfDecimals: number): number;
-    static Round(value: number, decimals: number): number;
-    static PrecisionScaleToMaxValue(precision: number, scale: number): number;
-    static DifferenceBetweenNumbers(numberA: number, numberB: number): number;
-    private static _GetLargestDecimalPrecisionOf;
-    private static _NumberInputToNumberStr;
-}
+import { CheckWithinSteppedBoundsResult } from "./check-within-stepped-bounds-result";
+import { CheckPrecisionAndScaleResult } from "./check-precision-and-scale-result";
+export declare class NumberUtils {
+    static ParseIntNumberInput(arg: any): number;
+    static ParseInt(arg: any): number;
+    static ParseFloatNumberInput(arg: any, decimalPrecision?: number): number;
+    static ParseFloatNumberInputKeepPrecision(arg: any): number;
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param {any} arg The argument to parse to a float
+     * @param {number} decimalPrecision The number of decimals, or the precision, the parsed return float should have
+     * @returns {number} NaN if not possible, else the parsed float value
+     */
+    static ParseFloat(arg: any, decimalPrecision?: number): number;
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param arg The argument to parse to a float
+     * @returns {number} The argument as a float with its original decimal precision intact
+     */
+    static ParseFloatKeepPrecision(arg: any): number;
+    /**
+     * Returns the given argument as a number. Returns given defaultValue if conversion of argument was impossible.
+     * @param arg
+     * @param {number} [defaultValue = 0]
+     * @returns {number}
+     */
+    static ParseNumberOrDefault(arg: any, defaultValue?: number): number;
+    static IsInteger(arg: any): boolean;
+    static GetDecimalPlaces(arg: any, maxAnswer?: number): number;
+    static ParseNumberInputOrDefault(numberInput: any, defaultValue?: number): number;
+    static IsNumber(arg: any): boolean;
+    /**
+     * Returns whether given arg is indeed not a number (it's NaN or it has another type than 'number')
+     * Our exact copy of AS Flex'es isNaN(arg) function. Always use this method for copying Flex isNaN(..) occurences into TypeScript.
+     * @param arg
+     * @returns {boolean}
+     * @constructor
+     */
+    static IsNaN(arg: any): boolean;
+    static NaN(number: any, substitute?: number): number;
+    static IsParsableNumber(arg: any): boolean;
+    static IsParsableNumberInput(numberInput: any): boolean;
+    /**
+     * Returns whether given arg is parseable as a number, and whether the lengts of its number parse result is equal to its original length.
+     * I.e. this function returns FALSE with given number-parsable strings, but that have non-numeric appendices, eg '2233ff'. That arg
+     * IS number-parseable, but not a strict 'string number', the latter being what this method actually checks for.
+     */
+    static IsStringNumber(arg: string): boolean;
+    static IsListOfNumbers(arg: string, separator?: string): boolean;
+    static ParseStringNumber(arg: string): number;
+    static ParseStringNumberDefault(arg: string | any, defaultValue?: number): number;
+    /**
+     * Returns a random integer in range [lowerBound .. upperBound], an inclusive range. Returns NaN if not possible.
+     * Given bounds are truncated first, before serving as the true lower- and upper bounds for the random int.
+     */
+    static RandomInt(lowerBoundInt: number, upperBoundInt: number): number;
+    static AddThousandsCommasTo(value: any): string;
+    /**
+     * Function used to check wether a given number is composed of another number, power-of-two wise.
+     * Example usage: NumberUtils.NumIsComposedOf(articleListObject.publication, ArticlePublication.Selector).
+     * This would return whether or not that articleListObject was publicated for selector or not, where articleListObject.publication
+     * was possibly a 'COMPOSITE that was made out of (including)' ArticlePublication.Selector.
+     */
+    static NumIsComposedOfOtherPowTwoNum(bigNrToCheck: number, powTwoNumItShouldBeComposedOf: number): boolean;
+    /**
+     * Returns given nr, or the given default number (default 0) if the nr number was undefined or otherwise not a number.
+     * Same as CoMath.NaN from AS code (used as its substitute in transaction logic)
+     * @param nr
+     * @param defaultNr
+     * @returns {number}
+     */
+    static NrOrDefault(nr: number, defaultNr?: number): number;
+    /**
+     * Returns whether given nrToCheck is within the given precision and scale limits. Precision and scale, here, are Oracle DB terms.
+     * This function can thus be used to check whether the given number is safe to send to the 'database' beforehand, if we know the
+     * precision and scale of the number in the db declaration.
+     *
+     * I.e. A number declared in the Oracle DB as number(5, 2) has a precision of 5 and a scale of 2.
+     *
+     * @param {number} nrToCheck
+     * @param {number} precision The number of significant digits, including possibly negative scale. E.g. 3 in '123' and 5 in '51.123'
+     * @param {number} [scale = 0] The number of significant digits AFTER the decimal point. E.g. 1 in 5432.1 and 3 in 54000.003
+     * @returns {CheckPrecisionAndScaleResult} Whether given nrToCheck is ok for given precision and scale, and if not, the
+     * nearest number that IS ok for those constraints.
+     */
+    static CheckPrecisionAndScale(nrToCheck: number, precision: number, scale?: number): CheckPrecisionAndScaleResult;
+    /**
+     * Returns whether given x is OK within the given min, max and step boundaries, where it should hold that nrToCheck = min + N * step,
+     * with N integer or 0.
+     * @param {number} nrToCheck Number to check whether it's within the given bounds
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns {CheckWithinSteppedBounds} Returns remainder of undefined when nrToCheck was OUTSIDE [min, max], else full result object.
+     */
+    static CheckWithinSteppedBounds(nrToCheck: number, min: number, max: number, stepSize?: number): CheckWithinSteppedBoundsResult;
+    /**
+     * Finds the number closest to the originalNumber, that adheres to the given bounds. That is, for which it holds that
+     * nr = min + N * step with N integer or 0.
+     * @param {number} originalNr Find closest answer to this number
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns {boolean} The closest OK number for bounds.
+     */
+    static GetNearestNumberWithinSteppedBounds(originalNr: number, min: number, max: number, stepSize?: number): number;
+    /**
+     * Returns the true maximum allowed value for the given "stepped bounds": min, stepSize and max, for which it holds that each allowed
+     * value Y = min + stepSize * N, for any INTEGER or 0 N where it also holds, of course, that Y <= max.
+     * @param min
+     * @param max
+     * @param stepSize
+     */
+    static GetTrueSteppedBoundsMax(min: number, max: number, stepSize?: number): number;
+    static GetNearestNumberWithinBounds(originalNr: number, min: number, max: number): number;
+    static ToString(nr: number): string;
+    static DecimalsToStepIncrement(numberOfDecimals: number): number;
+    static Round(value: number, decimals: number): number;
+    static PrecisionScaleToMaxValue(precision: number, scale: number): number;
+    static DifferenceBetweenNumbers(numberA: number, numberB: number): number;
+    private static _GetLargestDecimalPrecisionOf;
+    private static _NumberInputToNumberStr;
+}

package/lib/utils/object-utils.d.ts

@@ -1,40 +1,40 @@
-export declare class ObjectUtils {
-    /**
-     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
-     * @param {any} values Rest parameters with all objects to check existence for.
-     * @returns {boolean} True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
-     */
-    static AllExist(...values: any[]): boolean;
-    /**
-     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
-     * Does not copy functions, only properties.
-     * @param {Object} from The source object from which to copy all properties of to the 'to' object.
-     * @param {Object} to The object to which the properties of the 'from' object will be copied.
-     * @param {boolean} [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
-     */
-    static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined?: boolean): T;
-    static DeepEquals(actual: any, expected: any): boolean;
-    static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void;
-    static GetClassName(objectOrClass: any): string;
-    static GetShallowClone(originalObject: any, objectClass?: any): any;
-    static GetDeepClone(originalObject: any, circular?: boolean): any;
-    static IsEmpty(obj: any): boolean;
-    static IsPlainObject(object: any): boolean;
-    /**
-     * Returns an instance of given class with data of given dataObject. Only works if that class has a default constructor without args.
-     * Does not actually create a new object if it alread is an instance of that class.
-     * @param {any} clazz A class that has a default constructor
-     * @param {any} [dataObject] The object with data to copy to the new instance of the class
-     * @returns {any} An object that is an instance of given class, with given data applied to it.
-     */
-    static MakeInstanceOf(clazz: any, dataObject?: any): any;
-    static PickRandomPropertyValue(object: any): any;
-    static ValueOrDefault(value: any, defaultReturnVal?: any): any;
-    private static _isArguments;
-    private static _isArgumentsWhenArgsClassNotSupported;
-    private static _isArgumentsWhenArgsClassSupported;
-    private static _isBuffer;
-    private static _isUndefinedOrNull;
-    private static _objEquiv;
-    private static _supportsArgumentsClass;
-}
+export declare class ObjectUtils {
+    /**
+     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
+     * @param {any} values Rest parameters with all objects to check existence for.
+     * @returns {boolean} True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
+     */
+    static AllExist(...values: any[]): boolean;
+    /**
+     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
+     * Does not copy functions, only properties.
+     * @param {Object} from The source object from which to copy all properties of to the 'to' object.
+     * @param {Object} to The object to which the properties of the 'from' object will be copied.
+     * @param {boolean} [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
+     */
+    static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined?: boolean): T;
+    static DeepEquals(actual: any, expected: any): boolean;
+    static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void;
+    static GetClassName(objectOrClass: any): string;
+    static GetShallowClone(originalObject: any, objectClass?: any): any;
+    static GetDeepClone(originalObject: any, circular?: boolean): any;
+    static IsEmpty(obj: any): boolean;
+    static IsPlainObject(object: any): boolean;
+    /**
+     * Returns an instance of given class with data of given dataObject. Only works if that class has a default constructor without args.
+     * Does not actually create a new object if it alread is an instance of that class.
+     * @param {any} clazz A class that has a default constructor
+     * @param {any} [dataObject] The object with data to copy to the new instance of the class
+     * @returns {any} An object that is an instance of given class, with given data applied to it.
+     */
+    static MakeInstanceOf(clazz: any, dataObject?: any): any;
+    static PickRandomPropertyValue(object: any): any;
+    static ValueOrDefault(value: any, defaultReturnVal?: any): any;
+    private static _isArguments;
+    private static _isArgumentsWhenArgsClassNotSupported;
+    private static _isArgumentsWhenArgsClassSupported;
+    private static _isBuffer;
+    private static _isUndefinedOrNull;
+    private static _objEquiv;
+    private static _supportsArgumentsClass;
+}

package/lib/utils/ref-code-utils.d.ts

@@ -1,10 +1,10 @@
-export declare class RefCodeUtils {
-    static Check(valueToCheck: number, powTwoNumToCheckAgainst: number): boolean;
-    /**
-     * Returns true if given number value is a composition of at least one of the rest numeric arguments. Usesul for checking user rights,
-     * for instance, or any other numerical composite refcode.
-     */
-    static CheckAny(valueToCheck: number, ...powTwoNumsToCheckAgainst: number[]): boolean;
-    static GetMultiRefCodeChoices(multiRefCode: number): number[];
-    static GetNumbersArraySum(numbersArray: number[]): number;
-}
+export declare class RefCodeUtils {
+    static Check(valueToCheck: number, powTwoNumToCheckAgainst: number): boolean;
+    /**
+     * Returns true if given number value is a composition of at least one of the rest numeric arguments. Usesul for checking user rights,
+     * for instance, or any other numerical composite refcode.
+     */
+    static CheckAny(valueToCheck: number, ...powTwoNumsToCheckAgainst: number[]): boolean;
+    static GetMultiRefCodeChoices(multiRefCode: number): number[];
+    static GetNumbersArraySum(numbersArray: number[]): number;
+}

package/lib/utils/string-utils.d.ts

@@ -1,38 +1,38 @@
-export declare class StringUtils {
-    /**
-     * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
-     *
-     * Example usage:
-     *
-     * source = "ABCDABCD"
-     * placeholder = "BC"
-     * replacementTexts = "Z", "Z" (REST arguments)
-     * OUTPUT = "AZDAZD"
-     *
-     * @param {string} source
-     * @param {string} placeholder
-     * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
-     * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
-     */
-    static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string;
-    static ParseString(arg: any, defaultValue?: string): string;
-    static IsString(str: any): boolean;
-    static IsStringWithLength(str: string): boolean;
-    /**
-     * Example usage:
-     * str = 'File is to large to upload. Maximum file size is {0} Mb'
-     * format = [FileUtils.MaxUploadSizeInMb]
-     * output = File is to large to upload. Maximum file size is 3 Mb
-     *
-     * str = '{0} is way better than {1}'
-     * format = ['Angular2','Angular1']
-     * output = Angular2 is way better than Angular1
-     *
-     * @param str The string that contains {0} and {1} etc, for replacement by given format data
-     * @param format The format replacement data
-     * @returns {string}
-     */
-    static Format(str: string, format: any[]): string;
-    static RemoveLastChars(str: string, amount: number): string;
-    private static _escapeRegExp;
-}
+export declare class StringUtils {
+    /**
+     * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
+     *
+     * Example usage:
+     *
+     * source = "ABCDABCD"
+     * placeholder = "BC"
+     * replacementTexts = "Z", "Z" (REST arguments)
+     * OUTPUT = "AZDAZD"
+     *
+     * @param {string} source
+     * @param {string} placeholder
+     * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
+     * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
+     */
+    static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string;
+    static ParseString(arg: any, defaultValue?: string): string;
+    static IsString(str: any): boolean;
+    static IsStringWithLength(str: string): boolean;
+    /**
+     * Example usage:
+     * str = 'File is to large to upload. Maximum file size is {0} Mb'
+     * format = [FileUtils.MaxUploadSizeInMb]
+     * output = File is to large to upload. Maximum file size is 3 Mb
+     *
+     * str = '{0} is way better than {1}'
+     * format = ['Angular2','Angular1']
+     * output = Angular2 is way better than Angular1
+     *
+     * @param str The string that contains {0} and {1} etc, for replacement by given format data
+     * @param format The format replacement data
+     * @returns {string}
+     */
+    static Format(str: string, format: any[]): string;
+    static RemoveLastChars(str: string, amount: number): string;
+    private static _escapeRegExp;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colijnit/sharedcomponents",
-  "version": "1.0.64",
+  "version": "1.0.65",
   "private": false,
   "dependencies": {
     "chart.js": "4.3.0",