@colijnit/sharedcomponents 1.0.56 → 1.0.58

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

@@ -0,0 +1,110 @@
+import { __awaiter } from "tslib";
+import { EventEmitter, Injectable } from "@angular/core";
+import { SharedConnectorService } from "./shared-connector.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./shared-connector.service";
+export class StockService {
+    constructor(_sharedService) {
+        this._sharedService = _sharedService;
+        this.warehouseSelected = new EventEmitter();
+    }
+    // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {
+    //   await this._sharedService.getPrintStockStickers(data);
+    // }
+    // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {
+    //   await this._sharedService.getPrintPriceStickers(data);
+    // }
+    getStockHistory(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockHistory(data);
+        });
+    }
+    getStockInformation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockInformation(data);
+        });
+    }
+    // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    //   return await this._connector.getStockStickerPrintLayouts(data);
+    // }
+    getArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleDetails(data);
+        });
+    }
+    updateArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.updateArticleDetails(data);
+        });
+    }
+    getStockState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockStatus();
+        });
+    }
+    getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);
+        });
+    }
+    // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    //   return await this._sharedService.getStockStickerTemplates(data);
+    // }
+    getStockManagementWarehouses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockManagementWarehouses();
+        });
+    }
+    getStockManagementLocations(warehouseNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockManagementLocations(warehouseNo);
+        });
+    }
+    // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
+    //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);
+    // }
+    // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {
+    //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);
+    // }
+    // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {
+    //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);
+    // }
+    getArticleTransaction(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleTransaction(data);
+        });
+    }
+    stockPrognose(goodId, warehouseNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockPrognose(goodId, warehouseNumber);
+        });
+    }
+    lockArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.lockArticleDetails(data);
+        });
+    }
+    commit() {
+        return this._sharedService.commit();
+    }
+    getArticleFlat(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleFlat(sku);
+        });
+    }
+    searchArticles(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.searchArticles(request);
+        });
+    }
+}
+StockService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StockService_Factory() { return new StockService(i0.ɵɵinject(i1.SharedConnectorService)); }, token: StockService, providedIn: "root" });
+StockService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+StockService.ctorParameters = () => [
+    { type: SharedConnectorService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stock.service.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/service/stock.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAavD,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;;;AAWlE,MAAM,OAAO,YAAY;IAOvB,YACU,cAAsC;QAAtC,mBAAc,GAAd,cAAc,CAAwB;QAHhC,sBAAiB,GAA4C,IAAI,YAAY,EAA6B,CAAA;IAK1H,CAAC;IAED,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAEJ,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAES,eAAe,CAAC,IAA4B;;YACvD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACzD,CAAC;KAAA;IAEY,mBAAmB,CAAC,IAAkB;;YACjD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,oHAAoH;IACpH,oEAAoE;IACpE,IAAI;IAES,iBAAiB,CAAC,IAA4B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3D,CAAC;KAAA;IAEY,oBAAoB,CAAC,IAAsB;;YACtD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEY,aAAa;;YACxB,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,CAAC;QACpD,CAAC;KAAA;IAEY,iBAAiB,CAAC,MAAc,EAAE,QAAiB,EAAE,eAAwB,EAAE,WAAoB;;YAC9G,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;QACrG,CAAC;KAAA;IAED,iHAAiH;IACjH,qEAAqE;IACrE,IAAI;IAES,4BAA4B;;YACvC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,4BAA4B,EAAE,CAAC;QAClE,CAAC;KAAA;IAEY,2BAA2B,CAAC,WAAmB;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,2BAA2B,CAAC,WAAW,CAAC,CAAC;QAC5E,CAAC;KAAA;IAED,4FAA4F;IAC5F,wFAAwF;IACxF,IAAI;IAEJ,4GAA4G;IAC5G,sGAAsG;IACtG,IAAI;IAEJ,6GAA6G;IAC7G,oFAAoF;IACpF,IAAI;IAES,qBAAqB,CAAC,IAAwB;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC/D,CAAC;KAAA;IAEY,aAAa,CAAC,MAAc,EAAE,eAAuB;;YAChE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC7E,CAAC;KAAA;IAEY,kBAAkB,CAAC,IAA4B;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAC5D,CAAC;KAAA;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;IACtC,CAAC;IAEY,cAAc,CAAC,GAAW;;YACrC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC;KAAA;IAEY,cAAc,CAAC,OAA+B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3D,CAAC;KAAA;;;;YAjGF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAVO,sBAAsB","sourcesContent":["import {EventEmitter, Injectable} from \"@angular/core\";\r\nimport {PrintStockStickers} from \"@colijnit/sharedapi/build/model/print-stock-stickers\";\r\nimport {GetStockHistoryRequest} from \"@colijnit/articleapi/build/model/get-stock-history-request\";\r\nimport {ArticleStock as 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 {ArticleDetailsBo} from \"@colijnit/articleapi/build/model/article-details.bo\";\r\nimport {ArticleStockManagement} from \"@colijnit/articleapi/build/model/article-stock-management\";\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\nimport {ArticleTransaction} from \"@colijnit/articleapi/build/model/article-transaction\";\r\nimport {ArticleTransaction as ArticleTransactionBo} from \"@colijnit/articleapi/build/model/article-transaction.bo\";\r\nimport {SharedConnectorService} from \"./shared-connector.service\";\r\nimport {SendMethodParams} from \"../components/send-method-dialog/send-method-params.interface\";\r\nimport {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';\r\nimport {StockForecast} from \"@colijnit/articleapi/build/model/stock-forecast.bo\";\r\nimport {ArticleExtendedRequest} from \"@colijnit/articleapi/build/model/article-extended-request\";\r\nimport {ArticleExtended} from \"@colijnit/articleapi/build/model/article-extended.bo\";\r\nimport {ArticleFlat} from \"@colijnit/articleapi/build/model/article-flat.bo\";\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class StockService {\r\n\r\n  public stockStickers: PrintStockStickers;\r\n  public printLayoutParams: SendMethodParams;\r\n\r\n  public readonly warehouseSelected: EventEmitter<StockManagementWarehouses> = new EventEmitter<StockManagementWarehouses>()\r\n\r\n  constructor(\r\n    private _sharedService: SharedConnectorService,\r\n  ) {\r\n  }\r\n\r\n  // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {\r\n  //   await this._sharedService.getPrintStockStickers(data);\r\n  // }\r\n\r\n  // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {\r\n  //   await this._sharedService.getPrintPriceStickers(data);\r\n  // }\r\n\r\n  public async getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]> {\r\n    return await this._sharedService.getStockHistory(data);\r\n  }\r\n\r\n  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {\r\n    return await this._sharedService.getStockInformation(data);\r\n  }\r\n\r\n  // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\r\n  //   return await this._connector.getStockStickerPrintLayouts(data);\r\n  // }\r\n\r\n  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {\r\n    return await this._sharedService.getArticleDetails(data);\r\n  }\r\n\r\n  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {\r\n    return await this._sharedService.updateArticleDetails(data);\r\n  }\r\n\r\n  public async getStockState(): Promise<StockStatus[]> {\r\n    return await this._sharedService.getStockStatus();\r\n  }\r\n\r\n  public async getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {\r\n    return await this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);\r\n  }\r\n\r\n  // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\r\n  //   return await this._sharedService.getStockStickerTemplates(data);\r\n  // }\r\n\r\n  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {\r\n    return await this._sharedService.getStockManagementWarehouses();\r\n  }\r\n\r\n  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {\r\n    return await this._sharedService.getStockManagementLocations(warehouseNo);\r\n  }\r\n\r\n  // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {\r\n  //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);\r\n  // }\r\n\r\n  // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {\r\n  //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);\r\n  // }\r\n\r\n  // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {\r\n  //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);\r\n  // }\r\n\r\n  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {\r\n    return await this._sharedService.getArticleTransaction(data);\r\n  }\r\n\r\n  public async stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {\r\n    return await this._sharedService.getStockPrognose(goodId, warehouseNumber);\r\n  }\r\n\r\n  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {\r\n    return await this._sharedService.lockArticleDetails(data);\r\n  }\r\n\r\n  public commit(): Promise<DataServiceResponseData> {\r\n    return this._sharedService.commit();\r\n  }\r\n\r\n  public async getArticleFlat(sku: string): Promise<ArticleFlat> {\r\n    return await this._sharedService.getArticleFlat(sku);\r\n  }\r\n\r\n  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {\r\n    return await this._sharedService.searchArticles(request);\r\n  }\r\n\r\n\r\n\r\n\r\n}\r\n"]}

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

@@ -0,0 +1,202 @@
+import { ObjectUtils } from "./object-utils";
+import { NumberUtils } from "./number-utils";
+import { isNill } from "./is-nill.function";
+import { notNill } from "./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);
+            }
+        }
+    }
+    /**
+     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
+     * @param array
+     * @param itemValueFunction The function applied to each array item that gives it a numerical value. The max num val found is returned.
+     */
+    static GetMaxCalculatedValue(array, itemValueFunction) {
+        if (!array || !itemValueFunction) {
+            return NaN;
+        }
+        let max = undefined;
+        const len = array.length;
+        for (let i = 0; i < len; i++) {
+            const valueCur = itemValueFunction.call(this);
+            if (valueCur > max) {
+                max = valueCur;
+            }
+        }
+        return max;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/array-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAErD,MAAM,OAAO,UAAU;IACnB;;;;;;OAMG;IACI,MAAM,CAAC,wBAAwB,CAAI,KAAU,EAAE,MAA+B;QACjF,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE;YACnB,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAI,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,IAAI,CAAI,KAAU,EAAE,OAA6B;QAC3D,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE;YACpB,OAAO,SAAS,CAAC;SACpB;QAED,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,GAAG,GAAW,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;YAC9D,MAAM,OAAO,GAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5B,IAAI,OAAO,CAAC,OAAO,CAAC,EAAG;gBACnB,OAAO,OAAO,CAAC;aAClB;SACJ;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,4EAA4E;IACrE,MAAM,CAAC,OAAO,CAAI,KAAU,EAAE,OAA6B;QAC9D,MAAM,MAAM,GAAQ,EAAE,CAAC;QACvB,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE;YACpB,OAAO,MAAM,CAAC;SACjB;QAED,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,GAAG,GAAW,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;YAC9D,MAAM,OAAO,GAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5B,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACxB;SACJ;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,8DAA8D;IACvD,MAAM,CAAC,UAAU,CAAI,KAAU;QAClC,IAAI,MAAM,GAAQ,EAAE,CAAC;QAErB,IAAI,KAAK,EAAE;YACP,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAC3B;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,qBAAqB,CAAI,KAAU,EAAE,eAAqB,EAAE,YAAqB,KAAK;QAChG,MAAM,UAAU,GAAQ,EAAE,CAAC;QAE3B,IAAI,KAAK,EAAE;YACP,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,GAAG,GAAW,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;gBAC9D,IAAI,SAAS,EAAE;oBACX,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;iBACvD;qBAAM;oBACH,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;iBAC3E;aACJ;SACJ;aAAM;YACH,OAAO,EAAE,CAAC;SACb;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,oBAAoB,CAAC,KAAa,EAAE,KAAY;QAC1D,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtF,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,KAAK,IAAI,KAAK,EAAE;YAChB,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACvB,OAAO,IAAI,CAAC;SACf;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,aAAa,CAAI,OAAU,EAAE,KAAU;QACjD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACvB,OAAO,KAAK,CAAC;SAChB;QAED,MAAM,KAAK,GAAW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC7C,OAAO,UAAU,CAAC,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACzD,CAAC;IAED,+IAA+I;IACxI,MAAM,CAAC,mBAAmB,CAAI,YAAiB,EAAE,0BAAgC;QACpF,IAAI,MAAM,CAAC,YAAY,CAAC,EAAE;YACtB,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;YACxD,IAAI,0BAA0B,EAAE;gBAC5B,OAAO,YAAY,CAAC,CAAC,CAAC,YAAY,0BAA0B,CAAC;aAChE;iBAAM;gBACH,OAAO,IAAI,CAAC;aACf;SACJ;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED,sIAAsI;IAC/H,MAAM,CAAC,sBAAsB,CAAC,KAAY,EAAE,cAAsC;QACrF,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE;YAC3D,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,iBAAiB,GAAY,KAAK,CAAC;QAEvC,MAAM,GAAG,GAAW,KAAK,CAAC,MAAM,CAAC;QACjC,KAAK,IAAI,CAAC,GAAW,GAAG,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACvC,MAAM,IAAI,GAAQ,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3B,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,IAAI,EAAE;gBAC1C,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACnB,iBAAiB,GAAG,IAAI,CAAC;aAC5B;SACJ;QAED,OAAO,iBAAiB,CAAC;IAC7B,CAAC;IAEM,MAAM,CAAC,WAAW,CAAI,OAAU,EAAE,OAAe,EAAE,KAAU;QAChE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE;YAC1C,OAAO,KAAK,CAAC;SAChB;QAED,MAAM,SAAS,GAAW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,gBAAgB,GAAW,WAAW,CAAC,4BAA4B,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACxG,IAAI,SAAS,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,KAAK,OAAO,EAAE;YACzD,4EAA4E;YAC5E,OAAO,KAAK,CAAC;SAChB;QACD,KAAK,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,8IAA8I;IACvI,MAAM,CAAC,sBAAsB,CAAC,KAAY,EAAE,cAAmB,EAAE,gBAAqB;QACzF,IAAI,KAAK,EAAE;YACP,MAAM,cAAc,GAAW,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;YAC/D,MAAM,YAAY,GAAW,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YAC3D,IAAI,cAAc,IAAI,YAAY,EAAE;gBAChC,UAAU,CAAC,WAAW,CAAC,cAAc,EAAE,cAAc,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;aACrE;SACJ;IACL,CAAC;IAEH;;;;OAIG;IACI,MAAM,CAAC,qBAAqB,CAAI,KAAU,EAAE,iBAAsC;QACvF,IAAI,CAAC,KAAK,IAAI,CAAC,iBAAiB,EAAE;YAChC,OAAO,GAAG,CAAC;SACZ;QAED,IAAI,GAAG,GAAW,SAAS,CAAC;QAE5B,MAAM,GAAG,GAAW,KAAK,CAAC,MAAM,CAAC;QACjC,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;YACpC,MAAM,QAAQ,GAAW,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtD,IAAI,QAAQ,GAAG,GAAG,EAAE;gBAClB,GAAG,GAAG,QAAQ,CAAC;aAChB;SACF;QAED,OAAO,GAAG,CAAC;IACb,CAAC;CACF","sourcesContent":["import {ObjectUtils} from \"./object-utils\";\r\nimport {NumberUtils} from \"./number-utils\";\r\nimport {isNill} from \"./is-nill.function\";\r\nimport {notNill} from \"./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  /**\r\n   * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.\r\n   * @param array\r\n   * @param itemValueFunction The function applied to each array item that gives it a numerical value. The max num val found is returned.\r\n   */\r\n  public static GetMaxCalculatedValue<T>(array: T[], itemValueFunction: (item: T) => number): number {\r\n    if (!array || !itemValueFunction) {\r\n      return NaN;\r\n    }\r\n\r\n    let max: number = undefined;\r\n\r\n    const len: number = array.length;\r\n    for (let i: number = 0; i < len; i++) {\r\n      const valueCur: number = itemValueFunction.call(this);\r\n      if (valueCur > max) {\r\n        max = valueCur;\r\n      }\r\n    }\r\n\r\n    return max;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/utils/calendar.utils.js

@@ -0,0 +1,68 @@
+import { Weekday } from "../model/weekday.model";
+import { Inject, LOCALE_ID } from "@angular/core";
+import { LanguageCode } from "../enum/language-code.enum";
+import { Week } from "../model/week.model";
+export class CalendarUtils {
+    constructor(_locale) {
+        this._locale = _locale;
+        CalendarUtils.Locale = _locale;
+    }
+    // public static GetCurrentYear(): number {
+    //     return this.Now.getFullYear();
+    // }
+    //
+    // public static GetCurrentMonth(): number {
+    //     return this.Now.getUTCMonth() + 1;
+    // }
+    static GetDayHours(day) {
+        const datesByTheHour = [];
+        if (day) {
+            let newDate = new Date(day);
+            newDate.setHours(0, 0, 0, 0);
+            datesByTheHour.push(newDate);
+            for (let i = 0; i < 23; i++) {
+                newDate = new Date(newDate);
+                newDate.setHours(newDate.getHours() + 1);
+                datesByTheHour.push(newDate);
+            }
+        }
+        return datesByTheHour;
+    }
+    static GetDaysOfWeek(date) {
+        let day = new Date();
+        const daysOfWeek = [];
+        let options;
+        let month;
+        for (let i = 0; i < 3; i++) {
+            const dayPerWeek = new Weekday();
+            const dayHours = CalendarUtils.GetDayHours(day);
+            dayPerWeek.newMonth = day.getMonth() !== month;
+            dayPerWeek.weekdaySelected = day.getDay() === date.getDay();
+            dayPerWeek.weekdayDay = day.getDate();
+            options = { weekday: "short" };
+            dayPerWeek.weekdayShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { weekday: "long" };
+            dayPerWeek.weekdayLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { month: "short" };
+            dayPerWeek.weekdayMonthShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { month: "long" };
+            dayPerWeek.weekdayMonthLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+            dayPerWeek.weekdayYear = day.getFullYear();
+            dayPerWeek.date = new Date(day);
+            dayPerWeek.datesByTheHour = dayHours;
+            daysOfWeek.push(dayPerWeek);
+            month = day.getMonth();
+            day = new Date(day);
+            day.setDate(day.getDate() + 1);
+        }
+        const week = new Week();
+        week.weekDays = daysOfWeek;
+        return week;
+    }
+}
+CalendarUtils.Locale = undefined;
+CalendarUtils.Now = new Date();
+CalendarUtils.ctorParameters = () => [
+    { type: LanguageCode, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utils/check-precision-and-scale-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stcHJlY2lzaW9uLWFuZC1zY2FsZS1yZXN1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaGFyZWRjb21wb25lbnRzL3NyYy9saWIvdXRpbHMvY2hlY2stcHJlY2lzaW9uLWFuZC1zY2FsZS1yZXN1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8vIE91dHB1dCBvYmplY3Qgc2hhcGUgZm9yIE51bWJlclV0aWxzLkNoZWNrUHJlY2lzaW9uQW5kU2NhbGUoKS5cclxuZXhwb3J0IGludGVyZmFjZSBDaGVja1ByZWNpc2lvbkFuZFNjYWxlUmVzdWx0IHtcclxuICAgIGlzT2s6IGJvb2xlYW47XHJcbiAgICBuZWFyZXN0T2tOcj86IG51bWJlcjtcclxufVxyXG4iXX0=

package/esm2015/lib/utils/check-within-stepped-bounds-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2std2l0aGluLXN0ZXBwZWQtYm91bmRzLXJlc3VsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi91dGlscy9jaGVjay13aXRoaW4tc3RlcHBlZC1ib3VuZHMtcmVzdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogT3V0cHV0IG9iamVjdCBzaGFwZSBmb3IgTnVtYmVyVXRpbHMuQ2hlY2tXaXRoaW5TdGVwcGVkQm91bmRzKCkuIEZvciBlZmZpY2llbmN5LCB0aGlzIG1ldGhvZCBhbHNvIHJldHVybnMgdGhlIGZvdW5kIHJlbWFpbmRlciBpZiB0aGUgZ2l2ZW5cclxuICogbnVtYmVyIHdhcyBOT1Qgd2l0aGluIHRoZSBzcGVjaWZpZWQgc3RlcHBlZCBib3VuZHMuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIENoZWNrV2l0aGluU3RlcHBlZEJvdW5kc1Jlc3VsdCB7XHJcbiAgICBpc09rOiBib29sZWFuO1xyXG4gICAgcmVtYWluZGVyPzogbnVtYmVyO1xyXG59XHJcbiJdfQ==

package/esm2015/lib/utils/co-document-shared-field-logic.js

@@ -0,0 +1,50 @@
+import { FileType } from "../enum/file-type";
+export class CoDocumentSharedFieldLogic {
+    static BuildAllDocuments(documentation, images) {
+        let allDocuments = [];
+        allDocuments = allDocuments.concat(documentation);
+        allDocuments = allDocuments.concat(images);
+        allDocuments.sort((a, b) => {
+            return a.index < b.index ? -1 : 1;
+        });
+        return allDocuments;
+    }
+    static BuildImagesAndDocumentation(documents) {
+        const images = [];
+        const documentation = [];
+        const len = documents.length;
+        for (let i = 0; i < len; i++) {
+            // re-index documents order
+            documents[i].index = i + 1;
+            if (documents[i].fileType === FileType.Image) {
+                images.push(documents[i]);
+            }
+            else {
+                documentation.push(documents[i]);
+            }
+        }
+        return {
+            images: images,
+            documentation: documentation
+        };
+    }
+    // Returns an index number that is 1 higher than the highest one in the collection
+    static GenerateAvailableIndexNr(documents) {
+        const indexNumbers = [];
+        documents.forEach((collectionItem) => {
+            if (collectionItem && collectionItem.index > -1) {
+                indexNumbers.push(collectionItem.index);
+            }
+        });
+        indexNumbers.sort((a, b) => {
+            return a - b;
+        });
+        if (indexNumbers && indexNumbers.length > 0) {
+            return indexNumbers[indexNumbers.length - 1] + 1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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