@colijnit/sharedcomponents 1.0.11 → 1.0.14

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

@@ -0,0 +1,251 @@
+import { __awaiter } from "tslib";
+import { Articles } from "@colijnit/articleapi/build/articles";
+import { Sharedapi } from "@colijnit/sharedapi/build/sharedapi";
+import { Printer } from "@colijnit/sharedapi/build/model/report/printer.bo";
+import { Injectable } from "@angular/core";
+import { BusinessObjectFactory } from "../factory/business-object-factory";
+import { PrintStockStickers } from "@colijnit/sharedapi/build/model/print-stock-stickers";
+import { ArticleStockBo } from "@colijnit/articleapi/build/model/article-stock.bo";
+import { StockHistoryBo } from "@colijnit/articleapi/build/model/stock-history.bo";
+import { StockStickersPrintLayoutsBo } from "@colijnit/sharedapi/build/model/report/stock-stickers-print-layouts.bo";
+import { ArticleDetailsBo } from "@colijnit/articleapi/build/model/article-details.bo";
+import { StockStatus } from "@colijnit/articleapi/build/model/stock-status.bo";
+import { StockManagementWarehouses } from "@colijnit/articleapi/build/model/stock-management-warehouses.bo";
+import { StockLocation } from "@colijnit/articleapi/build/model/stock-location.bo";
+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.sharedConnector = new Sharedapi(options);
+                this.options.session = this.connector.session && this.sharedConnector.session;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.options = undefined;
+        });
+    }
+    getAllPrinters(showAll = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.sharedConnector.listAllPrinters(showAll).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObject) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Printer, result.resultObject));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getPrintStockStickers(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.sharedConnector.getPrintStockStickers(request).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObject) {
+                            resolve(this._boFactory.makeWithRawBackendData(PrintStockStickers, result.resultObject));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getStockStickerPrintLayouts(stockStickersPrintLayoutsBo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.sharedConnector.getStockStickerPrintLayouts(stockStickersPrintLayoutsBo).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObject) {
+                            resolve(this._boFactory.makeWithRawBackendData(stockStickersPrintLayoutsBo, result.resultObject));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    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);
+                    // }
+                });
+            });
+        });
+    }
+    getStockHistory(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getStockHistory(request).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObject && result.resultObject.hasOwnProperty("stockHistory")) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockHistoryBo, result.resultObject.stockHistory));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getStockInformation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getStockInformation(data).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObjects) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleStockBo, result.resultObjects));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getStockManagementWarehouses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getStockManagementWarehouses().then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObjects) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockManagementWarehouses, result.resultObjects));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getStockManagementLocations(warehouseNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getStockManagementLocations(warehouseNo).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObjects) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockLocation, result.resultObjects));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getArticleDetails(data).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObjects) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleDetailsBo, result.resultObjects));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    updateArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.updateArticleDetails(data).then((result) => __awaiter(this, void 0, void 0, function* () {
+                    if (result.validationResult && result.validationResult.success) {
+                        yield this.commit();
+                        resolve(true);
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                }));
+            });
+        });
+    }
+    lockArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.lockArticleDetails(data).then((result) => __awaiter(this, void 0, void 0, function* () {
+                    if (result.validationResult && result.validationResult.success) {
+                        yield this.commit();
+                        resolve(true);
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                }));
+            });
+        });
+    }
+    getStockStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.getStockState().then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObjects) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStatus, result.resultObjects));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    getStockStickerTemplates(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.sharedConnector.getStockStickerPrintLayouts(data).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        if (result.resultObject) {
+                            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStickersPrintLayoutsBo, result.resultObject));
+                        }
+                    }
+                    else {
+                        reject(result.validationMessagesAsString);
+                    }
+                });
+            });
+        });
+    }
+    commit() {
+        return this.connector.commit();
+    }
+}
+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,{"version":3,"file":"ione-connector-adapter.service.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/service/ione-connector-adapter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Articles} from \"@colijnit/articleapi/build/articles\";\r\nimport {Sharedapi} from \"@colijnit/sharedapi/build/sharedapi\";\r\nimport {Printer} from \"@colijnit/sharedapi/build/model/report/printer.bo\";\r\nimport {Injectable} from \"@angular/core\";\r\nimport {ArticleExtended} from \"@colijnit/articleapi/build/model/article-extended.bo\";\r\nimport {DataServiceResponseData} from \"@colijnit/articleapi/build/model/data-service-response-data\";\r\nimport {DataServiceResponseData as DataServiceResponse} from \"@colijnit/sharedapi/build/model/data-service-response-data\";\r\nimport {BusinessObjectFactory} from \"../factory/business-object-factory\";\r\nimport {PrintStockStickers} from \"@colijnit/sharedapi/build/model/print-stock-stickers\";\r\nimport {ArticlesPublic} from \"@colijnit/articleapi/build/articles-public\";\r\nimport {GetStockHistoryRequest} from \"@colijnit/articleapi/build/model/get-stock-history-request\";\r\nimport {ArticleStockBo} from \"@colijnit/articleapi/build/model/article-stock.bo\";\r\nimport {ArticleStock} from \"@colijnit/articleapi/build/model/article-stock\";\r\nimport {StockHistoryBo} from \"@colijnit/articleapi/build/model/stock-history.bo\";\r\nimport {StockStickersPrintLayoutsBo} from \"@colijnit/sharedapi/build/model/report/stock-stickers-print-layouts.bo\";\r\nimport {ArticleStockManagement} from \"@colijnit/articleapi/build/model/article-stock-management\";\r\nimport {ArticleDetailsBo} from \"@colijnit/articleapi/build/model/article-details.bo\";\r\nimport {StockStatus} from \"@colijnit/articleapi/build/model/stock-status.bo\";\r\nimport {StockManagementWarehouses} from \"@colijnit/articleapi/build/model/stock-management-warehouses.bo\";\r\nimport {StockLocation} from \"@colijnit/articleapi/build/model/stock-location.bo\";\r\n\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\n\r\nexport class IoneConnectorAdapterService {\r\n  public options: any;\r\n  public connector: Articles;\r\n  public sharedConnector: Sharedapi;\r\n\r\n  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();\r\n\r\n\r\n  constructor() {\r\n  }\r\n\r\n  public async connect(options: any): Promise<void> {\r\n    if (this.options === undefined) {\r\n      this.options = options;\r\n      this.connector = new Articles(options);\r\n      this.sharedConnector = new Sharedapi(options);\r\n      this.options.session = this.connector.session && this.sharedConnector.session;\r\n    }\r\n  }\r\n\r\n  public async disconnect(): Promise<void> {\r\n    this.options = undefined;\r\n  }\r\n\r\n  public async getAllPrinters(showAll: boolean = true): Promise<Printer[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.sharedConnector.listAllPrinters(showAll).then((result: DataServiceResponse) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObject) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Printer, result.resultObject));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getPrintStockStickers(request: PrintStockStickers): Promise<PrintStockStickers> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.sharedConnector.getPrintStockStickers(request).then((result: DataServiceResponse) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObject) {\r\n            resolve(this._boFactory.makeWithRawBackendData(PrintStockStickers, result.resultObject));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      })\r\n    })\r\n  }\r\n\r\n  public async getStockStickerPrintLayouts(stockStickersPrintLayoutsBo: StockStickersPrintLayoutsBo): Promise<StockStickersPrintLayoutsBo[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.sharedConnector.getStockStickerPrintLayouts(stockStickersPrintLayoutsBo).then((result: DataServiceResponse) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObject) {\r\n            resolve(this._boFactory.makeWithRawBackendData(stockStickersPrintLayoutsBo, result.resultObject));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      })\r\n    })\r\n  }\r\n\r\n  public async getArticleFullObject(goodId: number): Promise<ArticleExtended> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getArticleFullObject(goodId).then((result: DataServiceResponseData) => {\r\n        // if (result.validationResult && result.validationResult.success) {\r\n        //   if (result.resultObject) {\r\n        //     resolve(this._boFactory.makeWithRawBackendData(ArticleExtended, result.resultObject));\r\n        //   }\r\n        // } else {\r\n        //   reject(result.validationMessagesAsString);\r\n        // }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getStockHistory(request: GetStockHistoryRequest): Promise<StockHistoryBo[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getStockHistory(request).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObject && result.resultObject.hasOwnProperty(\"stockHistory\")) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockHistoryBo, result.resultObject.stockHistory));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      })\r\n    })\r\n  }\r\n\r\n  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getStockInformation(data).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObjects) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleStockBo, result.resultObjects));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getStockManagementWarehouses().then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObjects) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockManagementWarehouses, result.resultObjects));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getStockManagementLocations(warehouseNo).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObjects) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockLocation, result.resultObjects));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getArticleDetails(data).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObjects) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleDetailsBo, result.resultObjects));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.updateArticleDetails(data).then(async (result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          await this.commit();\r\n          resolve(true);\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockArticleDetails(data).then(async (result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          await this.commit();\r\n          resolve(true);\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n\r\n  public async getStockStatus(): Promise<StockStatus[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.getStockState().then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObjects) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStatus, result.resultObjects));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async getStockStickerTemplates(data: StockStickersPrintLayoutsBo): Promise<StockStickersPrintLayoutsBo[]> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.sharedConnector.getStockStickerPrintLayouts(data).then((result: DataServiceResponse) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          if (result.resultObject) {\r\n            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStickersPrintLayoutsBo, result.resultObject));\r\n          }\r\n        } else {\r\n          reject(result.validationMessagesAsString);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public commit(): Promise<DataServiceResponseData> {\r\n    return this.connector.commit();\r\n  }\r\n\r\n}\r\n"]}

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

@@ -0,0 +1,79 @@
+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 getPrintStockStickers(data: PrintStockStickers): Promise<void> {
+    //   await this._connector.getPrintStockStickers(data);
+    // }
+    getAllPrinters(showAll = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getAllPrinters(showAll);
+        });
+    }
+    getStockHistory(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockHistory(data);
+        });
+    }
+    getStockInformation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockInformation(data);
+        });
+    }
+    getStockStickerPrintLayouts(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockStickerPrintLayouts(data);
+        });
+    }
+    getArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getArticleDetails(data);
+        });
+    }
+    updateArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.updateArticleDetails(data);
+        });
+    }
+    getStockState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockStatus();
+        });
+    }
+    getStockStickerTemplates(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockStickerTemplates(data);
+        });
+    }
+    getStockManagementWarehouses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockManagementWarehouses();
+        });
+    }
+    getStockManagementLocations(warehouseNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.getStockManagementLocations(warehouseNo);
+        });
+    }
+    lockArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._connector.lockArticleDetails(data);
+        });
+    }
+    commit() {
+        return this._connector.commit();
+    }
+}
+StockService.decorators = [
+    { type: Injectable }
+];
+StockService.ctorParameters = () => [
+    { type: IoneConnectorAdapterService }
+];
+//# sourceMappingURL=data:application/json;base64,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

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,8 @@
  */
 export * from './lib/components/docsign/docsign.component';
 export * from './lib/components/docsign/docsign.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygc2hhcmVkY29tcG9uZW50c1xyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZG9jc2lnbi9kb2NzaWduLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZG9jc2lnbi9kb2NzaWduLm1vZHVsZSc7XHJcbiJdfQ==
+export * from './lib/components/stock/stock.component';
+export * from './lib/components/stock/stock.module';
+export * from './lib/components/send-method-dialog/send-method-dialog.component';
+export * from './lib/components/send-method-dialog/send-method-dialog.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsa0VBQWtFLENBQUM7QUFDakYsY0FBYywrREFBK0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzaGFyZWRjb21wb25lbnRzXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9kb2NzaWduL2RvY3NpZ24uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9kb2NzaWduL2RvY3NpZ24ubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9zdG9jay9zdG9jay5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3N0b2NrL3N0b2NrLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvc2VuZC1tZXRob2QtZGlhbG9nL3NlbmQtbWV0aG9kLWRpYWxvZy5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3NlbmQtbWV0aG9kLWRpYWxvZy9zZW5kLW1ldGhvZC1kaWFsb2cubW9kdWxlJztcclxuIl19