@colijnit/sharedcomponents 1.0.1 → 1.0.4

package/esm2015/lib/factory/decorators/complex-field.decorator.js

@@ -0,0 +1,57 @@
+import { notNill } from "@colijnit/articleapi/build/utils/function/not-nill.function";
+import { ObjectUtils } from "@colijnit/articleapi/build/utils/object-utils";
+const PROP_META_KEY = "complexField";
+/**
+ * !! just a TAG DECORATOR for now, there is no code that uses this meta data within the ione connector lib itself.
+ */
+/**
+ * Property decorator for properties of businessobject classes that are other strongly typed businessobjects.
+ * Ensures that the BusinessObjectFactoryService makes properly typed objects from incoming raw persistence data. Otherwise we couldn't add methods
+ * to our own businessobjects and use them, since all fields would be flat data without methods after BusinessObjectFactoryService creation.
+ *
+ * Usage:
+ *
+ * @ComplexField(Transaction)
+ * public transaction: Transaction
+ *
+ * Also keeps track of a "complexFieldProps" metadata on the class-level, as a reflect-metadata workaround to be able to
+ * retrieve all properties that have the @ComplexField(..) decorator (impossible with current Reflect API).
+ */
+export function ComplexField(type) {
+    return function (target, propertyKey) {
+        if (!target || !propertyKey) {
+            return;
+        }
+        // warn the programmer if given type was undefined; it's probably an import order glitch that caused this, because decorators seem
+        // to be immediately processed when a class is first imported
+        if (!type) {
+            // eslint-disable-next-line no-console
+            console.warn(`@ComplexField(type): type was UNDEFINED. Called on prop (${ObjectUtils.GetClassName(target)}, ${propertyKey}). ` +
+                `Class will not properly serialize and deserialize now. We've always been able to fix this by CHANGING IMPORT ORDERS ` +
+                `where both classes and their dependencies are used, e.g. factory, repository or models..`);
+            return;
+        }
+        Reflect.defineMetadata(PROP_META_KEY, type, target, propertyKey);
+    };
+}
+// Utility function holder of the ComplexFieldDecorator decorator.
+export class ComplexFieldDecorator {
+    /**
+     * Returns whether given property (as a string) on given object is a complex field. A complex field is a field that is decorated
+     * with the @ComplexField decorator.
+     */
+    static IsComplexField(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return false;
+        }
+        return (notNill(Reflect.getMetadata(PROP_META_KEY, target, propertyKey)));
+    }
+    // Returns the VALUE of the @ComplexField(VALUE) property decorator on the given propertyKey on the given modelObject.
+    static GetComplexFieldType(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return undefined;
+        }
+        return Reflect.getMetadata(PROP_META_KEY, target, propertyKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/factory/decorators/date-field.decorator.js

@@ -0,0 +1,36 @@
+import { DateUtils } from "@colijnit/articleapi/build/utils/date-utils";
+const PROP_META_KEY = "dateField";
+/**
+ * !! just a TAG DECORATOR for now, there is no code that uses this meta data within the ione connector lib itself.
+ */
+/**
+ * Property decorator for properties of businessobject classes that are of type Date, but are sent to us as strings.
+ * Ensures that the BusinessObjectFactory makes proper JavaScript Date objects from incoming strings for @DateField() decorated properties.
+ *
+ * Usage:
+ *
+ * @DateField()
+ * public expectedDeliveryDate: Date
+ */
+export function DateField() {
+    return function (target, propertyKey) {
+        if (!target || !propertyKey) {
+            return;
+        }
+        Reflect.defineMetadata(PROP_META_KEY, undefined, target, propertyKey);
+    };
+}
+// Utility function holder of the @DateField() decorator.
+export class DateFieldFieldDecorator {
+    // Returns whether given property (as a string) on given object is decorated with @DateField().
+    static IsDateField(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return false;
+        }
+        return Reflect.hasMetadata(PROP_META_KEY, target, propertyKey);
+    }
+    static StringAsDate(str) {
+        return DateUtils.StringAsDate(str);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/factory/decorators/string-number.decorator.js

@@ -0,0 +1,43 @@
+import { NumberUtils } from "@colijnit/articleapi/build/utils/number-utils";
+const PROP_META_KEY = "stringNumber";
+/**
+ * !! just a TAG DECORATOR for now, there is no code that uses this meta data within the ione connector lib itself.
+ */
+/**
+ * Decorator for properties of businessobjects that are sent to us as strings from the database, but which we want to use as a number in the client.
+ *
+ * Can be handy for incongruent backend api cases, where id data types are communicated wrongly via strings instead of numbers
+ * (e.g. on EmployeeFullObject.district, points to a District which has a number id, but in employee it's a string representation of that number...)
+ *
+ * Used by business object factory and -serializer.
+ *
+ * Usage:
+ *
+ * @StringNumber()
+ * public rights: UserRightType
+ */
+export function StringNumber() {
+    return function (target, propertyKey) {
+        if (!target || !propertyKey) {
+            return;
+        }
+        Reflect.defineMetadata(PROP_META_KEY, undefined, target, propertyKey);
+    };
+}
+// Utility function holder of the @StringNumber() decorator.
+export class StringNumberDecorator {
+    // Returns whether given property (as a string) on given object is decorated with @StringNumber().
+    static IsStringNumber(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return false;
+        }
+        return Reflect.hasMetadata(PROP_META_KEY, target, propertyKey);
+    }
+    static StringAsNumber(str) {
+        return NumberUtils.ParseFloatKeepPrecision(str);
+    }
+    static NumberAsString(nr) {
+        return "" + nr;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/model/business-object.js

@@ -0,0 +1,81 @@
+/**
+ * This type represents the concept of a business object ID type. ID's of business objects can be a primary number, a simple string or a
+ * object for a composite key.
+ *
+ * Simply to prevent type declarations of 'number | string | Object' for BO ID data all over the application.
+ */
+import { MapPropertyDecorator } from "@colijnit/articleapi/build/factory/decorators/map-property.decorator";
+import { BooleanTextDecorator } from "@colijnit/articleapi/build/factory/decorators/boolean.decorator";
+import { JsonFieldFieldDecorator } from "@colijnit/articleapi/build/factory/decorators/json.decorator";
+import { ComplexArrayDecorator } from "@colijnit/articleapi/build/factory/decorators/complex-array.decorator";
+export class BusinessObject {
+    constructor() {
+    }
+    // Overridable. Returns the ID of the model. Concrete model classes often override this method to provide their specific ID getter.
+    getId() {
+        return this.id;
+    }
+    setOwnMappedPropsFromRawData(rawData = {}) {
+        if (!rawData) {
+            return;
+        }
+        Object.keys(this).forEach((key) => {
+            // check if property needs to be mapped
+            if (MapPropertyDecorator.IsMapProperty(this, key)) {
+                const mapKeys = MapPropertyDecorator.GetMapProperty(this, key).split(",");
+                const len = mapKeys.length;
+                for (let i = 0; i < len; i++) {
+                    // eslint-disable-next-line
+                    const mapKey = mapKeys[i].trim();
+                    const objProp = rawData[mapKey];
+                    let decorated = false;
+                    if (rawData.hasOwnProperty(mapKey)) {
+                        if (BooleanTextDecorator.IsBooleanTextField(this, key)) {
+                            this[key] = BooleanTextDecorator.GetLogicalBooleanValue(objProp);
+                            decorated = true;
+                        }
+                        if (JsonFieldFieldDecorator.IsJsonField(this, key)) {
+                            this[key] = JsonFieldFieldDecorator.StringAsJson(objProp);
+                            decorated = true;
+                        }
+                        if (ComplexArrayDecorator.IsComplexArray(this, key)) {
+                            const arrayClass = ComplexArrayDecorator.GetComplexArrayType(this, key);
+                            // eslint-disable-next-line
+                            const origArray = this[key];
+                            // eslint-disable-next-line
+                            const newArray = [];
+                            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+                            for (let j = 0; j < origArray.length; j++) {
+                                // eslint-disable-next-line
+                                const item = new arrayClass(origArray[j]);
+                                newArray.push(item);
+                            }
+                            this[key] = newArray;
+                        }
+                        else {
+                            if (!decorated) {
+                                this[key] = objProp;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            else {
+                if (rawData.hasOwnProperty(key)) {
+                    const objProp = rawData[key];
+                    if (BooleanTextDecorator.IsBooleanTextField(this, key)) {
+                        this[key] = BooleanTextDecorator.GetLogicalBooleanValue(objProp);
+                    }
+                    else if (JsonFieldFieldDecorator.IsJsonField(this, key)) {
+                        this[key] = JsonFieldFieldDecorator.StringAsJson(objProp);
+                    }
+                    else {
+                        this[key] = objProp;
+                    }
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-object.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/model/business-object.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * This type represents the concept of a business object ID type. ID's of business objects can be a primary number, a simple string or a\r\n * object for a composite key.\r\n *\r\n * Simply to prevent type declarations of 'number | string | Object' for BO ID data all over the application.\r\n */\r\nimport {MapPropertyDecorator} from \"@colijnit/articleapi/build/factory/decorators/map-property.decorator\";\r\nimport {BooleanTextDecorator} from \"@colijnit/articleapi/build/factory/decorators/boolean.decorator\";\r\nimport {JsonFieldFieldDecorator} from \"@colijnit/articleapi/build/factory/decorators/json.decorator\";\r\nimport {ComplexArrayDecorator} from \"@colijnit/articleapi/build/factory/decorators/complex-array.decorator\";\r\n\r\nexport type BusinessObjectIDType = number | string | Object;\r\n\r\nexport abstract class BusinessObject {\r\n    // The ID of the model.\r\n    public id: BusinessObjectIDType;\r\n\r\n    // Overridable. Returns the ID of the model. Concrete model classes often override this method to provide their specific ID getter.\r\n    public getId(): BusinessObjectIDType {\r\n        return this.id;\r\n    }\r\n\r\n    constructor() {\r\n    }\r\n\r\n    protected setOwnMappedPropsFromRawData(rawData: any = {}): void {\r\n        if (!rawData) {\r\n            return;\r\n        }\r\n        Object.keys(this).forEach((key) => {\r\n            // check if property needs to be mapped\r\n            if (MapPropertyDecorator.IsMapProperty(this, key)) {\r\n                const mapKeys: string[] = MapPropertyDecorator.GetMapProperty(this, key).split(\",\");\r\n                const len: number = mapKeys.length;\r\n                for (let i: number = 0; i < len; i++) {\r\n                  // eslint-disable-next-line\r\n                    const mapKey = mapKeys[i].trim();\r\n                    const objProp: any = rawData[mapKey];\r\n                    let decorated: boolean = false;\r\n                    if (rawData.hasOwnProperty(mapKey)) {\r\n                        if (BooleanTextDecorator.IsBooleanTextField(this, key)) {\r\n                            this[key] = BooleanTextDecorator.GetLogicalBooleanValue(objProp);\r\n                            decorated = true;\r\n                        }\r\n                        if (JsonFieldFieldDecorator.IsJsonField(this, key)) {\r\n                            this[key] = JsonFieldFieldDecorator.StringAsJson(objProp);\r\n                            decorated = true;\r\n                        }\r\n                        if (ComplexArrayDecorator.IsComplexArray(this, key)) {\r\n                            const arrayClass: any = ComplexArrayDecorator.GetComplexArrayType(this, key);\r\n                          // eslint-disable-next-line\r\n                            const origArray = this[key];\r\n                          // eslint-disable-next-line\r\n                            const newArray = [];\r\n                          // eslint-disable-next-line @typescript-eslint/prefer-for-of\r\n                            for (let j = 0; j < origArray.length; j++) {\r\n                              // eslint-disable-next-line\r\n                                const item = new arrayClass(origArray[j]);\r\n                                newArray.push(item);\r\n                            }\r\n                            this[key] = newArray;\r\n                        } else {\r\n                            if (!decorated) {\r\n                                this[key] = objProp;\r\n                            }\r\n                        }\r\n                        break;\r\n                    }\r\n                }\r\n            } else {\r\n                if (rawData.hasOwnProperty(key)) {\r\n                    const objProp: any = rawData[key];\r\n                    if (BooleanTextDecorator.IsBooleanTextField(this, key)) {\r\n                        this[key] = BooleanTextDecorator.GetLogicalBooleanValue(objProp);\r\n                    } else if (JsonFieldFieldDecorator.IsJsonField(this, key)) {\r\n                        this[key] = JsonFieldFieldDecorator.StringAsJson(objProp);\r\n                    } else {\r\n                        this[key] = objProp;\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n}\r\n"]}

package/esm2015/lib/service/ione-connector-adapter.service.js

@@ -0,0 +1,47 @@
+import { __awaiter } from "tslib";
+import { Articles } from "@colijnit/articleapi/build/articles";
+import { Injectable } from "@angular/core";
+import { BusinessObjectFactory } from "../factory/business-object-factory";
+import * as i0 from "@angular/core";
+export class IoneConnectorAdapterService {
+    constructor() {
+        this._boFactory = new BusinessObjectFactory();
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options === undefined) {
+                this.options = options;
+                this.connector = new Articles(options);
+                this.options.session = this.connector.session;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.options = undefined;
+        });
+    }
+    getArticleFullObject(goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getArticleFullObject(goodId).then((result) => {
+                    // if (result.validationResult && result.validationResult.success) {
+                    //   if (result.resultObject) {
+                    //     resolve(this._boFactory.makeWithRawBackendData(ArticleExtended, result.resultObject));
+                    //   }
+                    // } else {
+                    //   reject(result.validationMessagesAsString);
+                    // }
+                });
+            });
+        });
+    }
+}
+IoneConnectorAdapterService.ɵprov = i0.ɵɵdefineInjectable({ factory: function IoneConnectorAdapterService_Factory() { return new IoneConnectorAdapterService(); }, token: IoneConnectorAdapterService, providedIn: "root" });
+IoneConnectorAdapterService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+IoneConnectorAdapterService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/stock.service.js

@@ -0,0 +1,40 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { IoneConnectorAdapterService } from "./ione-connector-adapter.service";
+export class StockService {
+    constructor(_connector) {
+        this._connector = _connector;
+    }
+    connectConnector(options) {
+        this._connector.connect(options);
+    }
+    // public async getStock(goodId: number): Promise<ArticleFullObject> {
+    //   return await this._connector.getArticleFullObject(goodId);
+    // }
+    // public async getStockHistory(): Promise<GetStockHistoryRequest> {
+    //
+    // }
+    // public async getStockWarehouses(goodId: number): Promise<getWarehouses>
+    loadStockLocations(goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // await this._connector.getArticleFullObject(goodId);
+        });
+    }
+    _loadInOrders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            //this.inOrderInformation = await ...
+        });
+    }
+    _loadStockOrders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this.orderInformation =  await ...
+        });
+    }
+}
+StockService.decorators = [
+    { type: Injectable }
+];
+StockService.ctorParameters = () => [
+    { type: IoneConnectorAdapterService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvY2suc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi9zZXJ2aWNlL3N0b2NrLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFDLDJCQUEyQixFQUFDLE1BQU0sa0NBQWtDLENBQUM7QUFHN0UsTUFBTSxPQUFPLFlBQVk7SUFHdkIsWUFDVSxVQUF1QztRQUF2QyxlQUFVLEdBQVYsVUFBVSxDQUE2QjtJQUdqRCxDQUFDO0lBRU0sZ0JBQWdCLENBQUMsT0FBWTtRQUNsQyxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRUQsc0VBQXNFO0lBQ3RFLCtEQUErRDtJQUMvRCxJQUFJO0lBRUosb0VBQW9FO0lBQ3BFLEVBQUU7SUFDRixJQUFJO0lBRUosMEVBQTBFO0lBRTdELGtCQUFrQixDQUFDLE1BQWM7O1lBQzVDLHNEQUFzRDtRQUN4RCxDQUFDO0tBQUE7SUFFYSxhQUFhOztZQUN6QixxQ0FBcUM7UUFDdkMsQ0FBQztLQUFBO0lBRWEsZ0JBQWdCOztZQUM1QixxQ0FBcUM7UUFDdkMsQ0FBQztLQUFBOzs7WUFsQ0YsVUFBVTs7O1lBRkgsMkJBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0lvbmVDb25uZWN0b3JBZGFwdGVyU2VydmljZX0gZnJvbSBcIi4vaW9uZS1jb25uZWN0b3ItYWRhcHRlci5zZXJ2aWNlXCI7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBTdG9ja1NlcnZpY2Uge1xyXG5cclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwcml2YXRlIF9jb25uZWN0b3I6IElvbmVDb25uZWN0b3JBZGFwdGVyU2VydmljZSxcclxuICApIHtcclxuXHJcbiAgfVxyXG5cclxuICBwdWJsaWMgY29ubmVjdENvbm5lY3RvcihvcHRpb25zOiBhbnkpOiB2b2lkIHtcclxuICAgIHRoaXMuX2Nvbm5lY3Rvci5jb25uZWN0KG9wdGlvbnMpO1xyXG4gIH1cclxuXHJcbiAgLy8gcHVibGljIGFzeW5jIGdldFN0b2NrKGdvb2RJZDogbnVtYmVyKTogUHJvbWlzZTxBcnRpY2xlRnVsbE9iamVjdD4ge1xyXG4gIC8vICAgcmV0dXJuIGF3YWl0IHRoaXMuX2Nvbm5lY3Rvci5nZXRBcnRpY2xlRnVsbE9iamVjdChnb29kSWQpO1xyXG4gIC8vIH1cclxuXHJcbiAgLy8gcHVibGljIGFzeW5jIGdldFN0b2NrSGlzdG9yeSgpOiBQcm9taXNlPEdldFN0b2NrSGlzdG9yeVJlcXVlc3Q+IHtcclxuICAvL1xyXG4gIC8vIH1cclxuXHJcbiAgLy8gcHVibGljIGFzeW5jIGdldFN0b2NrV2FyZWhvdXNlcyhnb29kSWQ6IG51bWJlcik6IFByb21pc2U8Z2V0V2FyZWhvdXNlcz5cclxuXHJcbiAgcHVibGljIGFzeW5jIGxvYWRTdG9ja0xvY2F0aW9ucyhnb29kSWQ6IG51bWJlcik6IFByb21pc2U8dm9pZD4ge1xyXG4gICAgLy8gYXdhaXQgdGhpcy5fY29ubmVjdG9yLmdldEFydGljbGVGdWxsT2JqZWN0KGdvb2RJZCk7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGFzeW5jIF9sb2FkSW5PcmRlcnMoKTogUHJvbWlzZTx2b2lkPiB7XHJcbiAgICAvL3RoaXMuaW5PcmRlckluZm9ybWF0aW9uID0gYXdhaXQgLi4uXHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGFzeW5jIF9sb2FkU3RvY2tPcmRlcnMoKTogUHJvbWlzZTx2b2lkPiB7XHJcbiAgICAvLyB0aGlzLm9yZGVySW5mb3JtYXRpb24gPSAgYXdhaXQgLi4uXHJcbiAgfVxyXG5cclxufVxyXG4iXX0=

package/esm2015/lib/utils/array-utils.js

@@ -0,0 +1,183 @@
+import { ObjectUtils } from "@colijnit/articleapi/build/utils/object-utils";
+import { NumberUtils } from "@colijnit/articleapi/build/utils/number-utils";
+import { isNill } from "@colijnit/articleapi/build/utils/function/is-nill.function";
+import { notNill } from "@colijnit/articleapi/build/utils/function/not-nill.function";
+export class ArrayUtils {
+    /**
+     * Returns whether at least one element in given array could be found by given finder function.
+     *
+     * @param {T[]} array
+     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents
+     * the 'found status' for that element; whether it should have been found or not.
+     */
+    static ContainsAnElementFoundBy(array, finder) {
+        if (!array || !finder) {
+            return false;
+        }
+        return notNill(this.Find(array, finder));
+    }
+    /**
+     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
+     * undefined when none was found.
+     *
+     * Example usage:
+     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
+     *     (return modelItem.getId() === '1')
+     *   * });
+     *
+     * @param array The array with items to search in.
+     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
+     */
+    static Find(array, foundBy) {
+        if (!array || !foundBy) {
+            return undefined;
+        }
+        for (let i = 0, len = array.length; i < len; i++) {
+            const itemCur = array[i];
+            if (foundBy(itemCur)) {
+                return itemCur;
+            }
+        }
+        return undefined;
+    }
+    // @returns empty array when nothing found, otherwise array with found items
+    static FindAll(array, foundBy) {
+        const answer = [];
+        if (!array || !foundBy) {
+            return answer;
+        }
+        for (let i = 0, len = array.length; i < len; i++) {
+            const itemCur = array[i];
+            if (foundBy(itemCur)) {
+                answer.push(itemCur);
+            }
+        }
+        return answer;
+    }
+    // returns a simple clone of given array, using array.slice(0)
+    static CloneArray(array) {
+        let answer = [];
+        if (array) {
+            answer = array.slice(0);
+        }
+        return answer;
+    }
+    /**
+     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),
+     * or just as plain object (see param arrayItemsClass).
+     * @param array
+     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
+     * it'll be a plain object.
+     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..
+     * @returns {Array} semi-deep clone of given array
+     */
+    static CloneArrayAndItsItems(array, arrayItemsClass, deepClone = false) {
+        const cloneArray = [];
+        if (array) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (deepClone) {
+                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));
+                }
+                else {
+                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));
+                }
+            }
+        }
+        else {
+            return [];
+        }
+        return cloneArray;
+    }
+    /**
+     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
+     * removes the element using splice().
+     *
+     * @param {number} index
+     * @param {any[]} array in-out
+     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.
+     */
+    static RemoveElementAtIndex(index, array) {
+        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {
+            return false;
+        }
+        if (index in array) {
+            array.splice(index, 1);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the
+     * element using splice(). Also works on associative arrays.
+     *
+     * @param {T} element The element to remove.
+     * @param {T[]} array The array to remove the element from.
+     * @returns {boolean} True iff given element was truly successfully removed from given array.
+     */
+    static RemoveElement(element, array) {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        const index = array.indexOf(element);
+        return ArrayUtils.RemoveElementAtIndex(index, array);
+    }
+    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.
+    static IsArrayWithElements(arrayToCheck, classItemsMustBeInstanceOf) {
+        if (isNill(arrayToCheck)) {
+            return false;
+        }
+        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
+            if (classItemsMustBeInstanceOf) {
+                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.
+    static RemoveElementsByFilter(array, filterFunction) {
+        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {
+            return false;
+        }
+        let atLeastOneRemoved = false;
+        const len = array.length;
+        for (let i = len - 1; i >= 0; i--) {
+            const item = array[i];
+            if (filterFunction.call(this, item) === true) {
+                array.splice(i, 1);
+                atLeastOneRemoved = true;
+            }
+        }
+        return atLeastOneRemoved;
+    }
+    static MoveElement(element, toIndex, array) {
+        if (!Array.isArray(array) || isNill(toIndex)) {
+            return false;
+        }
+        const fromIndex = array.indexOf(element);
+        const toIndexCorrected = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);
+        if (fromIndex === -1 || array[toIndexCorrected] === element) {
+            // element did not exist in given array, or already existed on given toIndex
+            return false;
+        }
+        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);
+        return true;
+    }
+    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.
+    static PlaceElementAfterOther(array, elementToPlace, afterThisElement) {
+        if (array) {
+            const afterThisElIdx = array.indexOf(afterThisElement);
+            const elToPlaceIdx = array.indexOf(elementToPlace);
+            if (afterThisElIdx >= elToPlaceIdx) {
+                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/array-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {ObjectUtils} from \"@colijnit/articleapi/build/utils/object-utils\";\r\nimport {NumberUtils} from \"@colijnit/articleapi/build/utils/number-utils\";\r\nimport {isNill} from \"@colijnit/articleapi/build/utils/function/is-nill.function\";\r\nimport {notNill} from \"@colijnit/articleapi/build/utils/function/not-nill.function\";\r\n\r\nexport class ArrayUtils {\r\n    /**\r\n     * Returns whether at least one element in given array could be found by given finder function.\r\n     *\r\n     * @param {T[]} array\r\n     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents\r\n     * the 'found status' for that element; whether it should have been found or not.\r\n     */\r\n    public static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean {\r\n        if (!array || !finder) {\r\n            return false;\r\n        }\r\n\r\n        return notNill(this.Find<T>(array, finder));\r\n    }\r\n\r\n    /**\r\n     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns\r\n     * undefined when none was found.\r\n     *\r\n     * Example usage:\r\n     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>\r\n     *     (return modelItem.getId() === '1')\r\n     *   * });\r\n     *\r\n     * @param array The array with items to search in.\r\n     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.\r\n     */\r\n    public static Find<T>(array: T[], foundBy: (item: T) => boolean): T {\r\n        if (!array || !foundBy) {\r\n            return undefined;\r\n        }\r\n\r\n        for (let i: number = 0, len: number = array.length; i < len; i++) {\r\n            const itemCur: T = array[i];\r\n            if (foundBy(itemCur) ) {\r\n                return itemCur;\r\n            }\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    // @returns empty array when nothing found, otherwise array with found items\r\n    public static FindAll<T>(array: T[], foundBy: (item: T) => boolean): T[] {\r\n        const answer: T[] = [];\r\n        if (!array || !foundBy) {\r\n            return answer;\r\n        }\r\n\r\n        for (let i: number = 0, len: number = array.length; i < len; i++) {\r\n            const itemCur: T = array[i];\r\n            if (foundBy(itemCur)) {\r\n                answer.push(itemCur);\r\n            }\r\n        }\r\n        return answer;\r\n    }\r\n\r\n    // returns a simple clone of given array, using array.slice(0)\r\n    public static CloneArray<T>(array: T[]): T[] {\r\n        let answer: T[] = [];\r\n\r\n        if (array) {\r\n            answer = array.slice(0);\r\n        }\r\n\r\n        return answer;\r\n    }\r\n\r\n    /**\r\n     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),\r\n     * or just as plain object (see param arrayItemsClass).\r\n     * @param array\r\n     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise\r\n     * it'll be a plain object.\r\n     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..\r\n     * @returns {Array} semi-deep clone of given array\r\n     */\r\n    public static CloneArrayAndItsItems<T>(array: T[], arrayItemsClass?: any, deepClone: boolean = false): T[] {\r\n        const cloneArray: T[] = [];\r\n\r\n        if (array) {\r\n            for (let i: number = 0, len: number = array.length; i < len; i++) {\r\n                if (deepClone) {\r\n                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));\r\n                } else {\r\n                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));\r\n                }\r\n            }\r\n        } else {\r\n            return [];\r\n        }\r\n\r\n        return cloneArray;\r\n    }\r\n\r\n    /**\r\n     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really\r\n     * removes the element using splice().\r\n     *\r\n     * @param {number} index\r\n     * @param {any[]} array in-out\r\n     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.\r\n     */\r\n    public static RemoveElementAtIndex(index: number, array: any[]): boolean {\r\n        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {\r\n            return false;\r\n        }\r\n\r\n        if (index in array) {\r\n            array.splice(index, 1);\r\n            return true;\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the\r\n     * element using splice(). Also works on associative arrays.\r\n     *\r\n     * @param {T} element The element to remove.\r\n     * @param {T[]} array The array to remove the element from.\r\n     * @returns {boolean} True iff given element was truly successfully removed from given array.\r\n     */\r\n    public static RemoveElement<T>(element: T, array: T[]): boolean {\r\n        if (!Array.isArray(array)) {\r\n            return false;\r\n        }\r\n\r\n        const index: number = array.indexOf(element);\r\n        return ArrayUtils.RemoveElementAtIndex(index, array);\r\n    }\r\n\r\n    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.\r\n    public static IsArrayWithElements<T>(arrayToCheck: T[], classItemsMustBeInstanceOf?: any): boolean {\r\n        if (isNill(arrayToCheck)) {\r\n            return false;\r\n        }\r\n\r\n        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {\r\n            if (classItemsMustBeInstanceOf) {\r\n                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;\r\n            } else {\r\n                return true;\r\n            }\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.\r\n    public static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean {\r\n        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {\r\n            return false;\r\n        }\r\n\r\n        let atLeastOneRemoved: boolean = false;\r\n\r\n        const len: number = array.length;\r\n        for (let i: number = len - 1; i >= 0; i--) {\r\n            const item: any = array[i];\r\n            if (filterFunction.call(this, item) === true) {\r\n                array.splice(i, 1);\r\n                atLeastOneRemoved = true;\r\n            }\r\n        }\r\n\r\n        return atLeastOneRemoved;\r\n    }\r\n\r\n    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {\r\n        if (!Array.isArray(array) || isNill(toIndex)) {\r\n            return false;\r\n        }\r\n\r\n        const fromIndex: number = array.indexOf(element);\r\n        const toIndexCorrected: number = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);\r\n        if (fromIndex === -1 || array[toIndexCorrected] === element) {\r\n            // element did not exist in given array, or already existed on given toIndex\r\n            return false;\r\n        }\r\n        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);\r\n        return true;\r\n    }\r\n\r\n    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.\r\n    public static PlaceElementAfterOther(array: any[], elementToPlace: any, afterThisElement: any): void {\r\n        if (array) {\r\n            const afterThisElIdx: number = array.indexOf(afterThisElement);\r\n            const elToPlaceIdx: number = array.indexOf(elementToPlace);\r\n            if (afterThisElIdx >= elToPlaceIdx) {\r\n                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/utils/is-nill.function.js

@@ -0,0 +1,5 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value) {
+    return value === null || value === undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbmlsbC5mdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi91dGlscy9pcy1uaWxsLmZ1bmN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdFQUFnRTtBQUNoRSxNQUFNLFVBQVUsTUFBTSxDQUFDLEtBQVU7SUFDN0IsT0FBTyxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTLENBQUM7QUFDakQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEByZXR1cm5zIHRydWUgaWZmIGdpdmVuIHZhbHVlIGVxdWFscyBudWxsIG9yIGVxdWFscyB1bmRlZmluZWRcclxuZXhwb3J0IGZ1bmN0aW9uIGlzTmlsbCh2YWx1ZTogYW55KTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdmFsdWUgPT09IG51bGwgfHwgdmFsdWUgPT09IHVuZGVmaW5lZDtcclxufSJdfQ==

package/esm2015/public-api.js

@@ -3,4 +3,6 @@
  */
 export * from './lib/components/docsign/docsign.component';
 export * from './lib/components/docsign/docsign.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHNoYXJlZGNvbXBvbmVudHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2RvY3NpZ24vZG9jc2lnbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9kb2NzaWduL2RvY3NpZ24ubW9kdWxlJztcbiJdfQ==
+export * from './lib/components/stock/stock.component';
+export * from './lib/components/stock/stock.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHFDQUFxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHNoYXJlZGNvbXBvbmVudHNcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2RvY3NpZ24vZG9jc2lnbi5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2RvY3NpZ24vZG9jc2lnbi5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3N0b2NrL3N0b2NrLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvc3RvY2svc3RvY2subW9kdWxlJztcclxuIl19