@pksep/zod-shared 0.0.490

package/dist/utils/methods.js

@@ -0,0 +1,1286 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intersect = exports.shipmentsNullOne = exports.differencesShipments = exports.dateDifference = exports.toFormatString = exports.comparison = exports.comparisonTimestamp = exports.parseDate = exports.dataFormat = exports.dateToTimestampFormat = exports.convertStringValuesToNumbers = exports.dateToFormat = exports.photoPreloadUrl = exports.isImage = exports.getReversDate = exports.isValidNumber = exports.returnTypePosition = exports.checkMissingEntity = exports.countChildrensRelative = exports.countUniqueValueChildren = exports.removeArrDublicateByAttr = exports.getOnCommonListChildrens = exports.sleep = exports.parseBoolean = exports.strIsBoolean = exports.useWorkpieceCharacterizationItems = exports.getFileType = exports.calculateEndDate = exports.leftToDoByProductionTask = exports.calculateByMeasurementRate = void 0;
+exports.moreMinusNum = moreMinusNum;
+exports.getFieldsSpetification = getFieldsSpetification;
+exports.isThisExclusionDesignation = isThisExclusionDesignation;
+exports.organiseListCbedDetal = organiseListCbedDetal;
+exports.getFieldBySpetificationList = getFieldBySpetificationList;
+exports.lessPlusNum = lessPlusNum;
+exports.copyObject = copyObject;
+exports.addListSpetificationJSONB = addListSpetificationJSONB;
+exports.updateDataForSpetification = updateDataForSpetification;
+exports.returnOnlyDifferentData = returnOnlyDifferentData;
+exports.returnDeletedSpecificationItems = returnDeletedSpecificationItems;
+exports.returnOnlyDifferentListData = returnOnlyDifferentListData;
+exports.sortOperationsByIdx = sortOperationsByIdx;
+exports.appendedParentAttr = appendedParentAttr;
+exports.eSelectSpan = eSelectSpan;
+exports.compareShipmentWorkingDate = compareShipmentWorkingDate;
+exports.posToDeliveries = posToDeliveries;
+exports.sliceName = sliceName;
+exports.returnDificit = returnDificit;
+exports.openInNewTab = openInNewTab;
+const edizm_1 = require("./edizm");
+const enums_1 = require("./enums");
+const types_1 = require("./types");
+/**
+ * Возвращает ноль или число больше нуля
+ * @param num
+ * @returns
+ */
+function moreMinusNum(num) {
+    const res = num < 0 ? 0 : num;
+    return Number.isNaN(res) ? 0 : res;
+}
+/**
+ * достает все subKey из listCbed | listDet | materialList
+ * @param listCbed
+ * @param key
+ * @param subKey
+ * @returns
+ */
+function getFieldsSpetification(list, subKey) {
+    try {
+        if (!list.length)
+            return null;
+        const subKeyValuesArray = list.map(currentObject => currentObject[subKey]);
+        return subKeyValuesArray;
+    }
+    catch (error) {
+        return null;
+    }
+}
+const calculateByMeasurementRate = (units_measurement, ezId) => {
+    const unitsMeasurementMap = new Map(units_measurement.map(unit => [unit.unitTypeId, unit.convertRate]));
+    if (!unitsMeasurementMap.has(ezId))
+        return 0;
+    const convertRate = ezId === 1 ? 1 : unitsMeasurementMap.get(ezId);
+    return convertRate;
+};
+exports.calculateByMeasurementRate = calculateByMeasurementRate;
+/**
+ * Функция проверяет, является ли введенное обозначение исключением
+ */
+function isThisExclusionDesignation(designation, isProduct = false) {
+    let exclusions = ['-', '', '?', '- архив'];
+    const productExclusions = [
+        'покупной',
+        '',
+        'ремонт',
+        'документ',
+        'оснастка',
+        'опция'
+    ];
+    if (isProduct)
+        exclusions = exclusions.concat(productExclusions);
+    const lowerDesignation = `${designation}`.toLowerCase();
+    return exclusions.includes(lowerDesignation);
+}
+/**
+ *
+ * @param marks
+ * @param myQuantity
+ * @param productionTaskId
+ * @returns
+ * Функция подсчитывает необходимый остаток по ПЗ
+ */
+const leftToDoByProductionTask = (marks, myQuantity, productionTaskId) => {
+    if (!marks)
+        return myQuantity;
+    const createByMarks = marks.reduce((curr, mark) => mark.production_task_id === productionTaskId
+        ? curr + Number(mark.kol)
+        : curr, 0);
+    return moreMinusNum(myQuantity - createByMarks);
+};
+exports.leftToDoByProductionTask = leftToDoByProductionTask;
+/**
+ *
+ * @param startDate
+ * @param totalMinutes
+ * @returns
+ * Возвращает время окончания работы над ТЗ
+ * Обратить внимание, что считается только рабочее время.
+ * Суббота и воскресенье не считаются за рабочий день.
+ */
+/**
+ *
+ * @param startDate
+ * @param totalMinutes
+ * @returns
+ * Возвращает время окончания работы над ТЗ
+ * Обратить внимание, что считается только рабочее время.
+ * Суббота и воскресенье не считаются за рабочий день.
+ * Если startDate выходит за пределы рабочего времени, отсчет начинается от ближайшей рабочей даты.
+ */
+const calculateEndDate = (startDate, totalMinutes) => {
+    let currentDate = new Date(startDate);
+    let remainingMinutes = totalMinutes;
+    const workDayStartHour = 5;
+    const workDayHours = 8;
+    const workDayEndHour = workDayStartHour + workDayHours;
+    // Функция для проверки, является ли дата рабочим днем
+    const isWorkDay = (date) => {
+        const dayOfWeek = date.getUTCDay();
+        return dayOfWeek !== 0 && dayOfWeek !== 6;
+    };
+    const getWorkDayStart = (date) => {
+        const start = new Date(date);
+        start.setUTCHours(workDayStartHour, 0, 0, 0);
+        return start;
+    };
+    const getWorkDayEnd = (date) => {
+        const end = new Date(date);
+        end.setUTCHours(workDayEndHour, 0, 0, 0);
+        return end;
+    };
+    const moveToNextWorkDay = (date) => {
+        const nextDay = new Date(date);
+        do {
+            nextDay.setUTCDate(nextDay.getUTCDate() + 1);
+        } while (!isWorkDay(nextDay));
+        nextDay.setUTCHours(workDayStartHour, 0, 0, 0);
+        return nextDay;
+    };
+    if (!isWorkDay(currentDate)) {
+        currentDate = moveToNextWorkDay(currentDate);
+    }
+    else {
+        const currentHour = currentDate.getUTCHours();
+        const currentMinutes = currentDate.getUTCMinutes();
+        const currentTimeInMinutes = currentHour * 60 + currentMinutes;
+        const workDayStartInMinutes = workDayStartHour * 60;
+        const workDayEndInMinutes = workDayEndHour * 60;
+        if (currentTimeInMinutes < workDayStartInMinutes) {
+            currentDate = getWorkDayStart(currentDate);
+        }
+        else if (currentTimeInMinutes >= workDayEndInMinutes) {
+            currentDate = moveToNextWorkDay(currentDate);
+        }
+    }
+    while (remainingMinutes > 0) {
+        const workDayEnd = getWorkDayEnd(currentDate);
+        const availableMinutesToday = Math.min(remainingMinutes, (workDayEnd.getTime() - currentDate.getTime()) / (1000 * 60));
+        if (availableMinutesToday > 0) {
+            currentDate = new Date(currentDate.getTime() + availableMinutesToday * 60 * 1000);
+            remainingMinutes -= availableMinutesToday;
+        }
+        if (remainingMinutes > 0) {
+            currentDate = moveToNextWorkDay(currentDate);
+        }
+    }
+    return currentDate;
+};
+exports.calculateEndDate = calculateEndDate;
+/**
+ * Функция получает сущность и генерирует из него элемент спецификации
+ * @param entity
+ * @param type
+ * @returns
+ */
+function organiseListCbedDetal(entity, type) {
+    return {
+        type: type,
+        entity: {
+            id: entity.id,
+            name: entity.name,
+            designation: entity.designation
+        },
+        kol: entity.quantity
+    };
+}
+/**
+ * Получаем поле из спецификакии
+ * @param list
+ * @param id
+ * @param field
+ * @returns
+ */
+function getFieldBySpetificationList(list, id, field) {
+    try {
+        const parseList = list.length ? list : [];
+        for (const item of parseList) {
+            if ((item === null || item === void 0 ? void 0 : item.id) === id)
+                return item[field];
+        }
+        return null;
+    }
+    catch (err) {
+        return null;
+    }
+}
+/**
+ * Возвращает ноль или число меньше нуля
+ * @param num
+ * @returns
+ */
+function lessPlusNum(num) {
+    const res = num > 0 ? 0 : num;
+    return Number.isNaN(res) ? 0 : res;
+}
+/**
+ * Рекурсивно клонирует объект или массив
+ * @param object
+ * @deprecated use lodash method _.deepClone or
+ * Object.assign({}, entity), or operation extension { ...entity }
+ * @returns
+ */
+function copyObject(object) {
+    const len = Object.keys(object).length;
+    let newObject;
+    if (len > 1000) {
+        // Обработка очень большого объекта
+        const chankObject = {};
+        const chankArray = [];
+        for (const key in object) {
+            const arrayStrings = JSON.stringify(object[key]);
+            if (Array.isArray(object))
+                chankArray.push(JSON.parse(arrayStrings));
+            else
+                chankObject[key] = JSON.parse(arrayStrings);
+        }
+        newObject = Array.isArray(object) ? chankArray : chankObject;
+    }
+    else
+        newObject = JSON.parse(JSON.stringify(object));
+    return newObject;
+}
+/**
+ * Получаем тип файла
+ * @param str 'file.jpg' | 'file.doc'
+ * @returns 'jpg' | 'doc' | ''
+ */
+const getFileType = (str) => {
+    var _a;
+    const endString = (_a = str
+        .split('.')[str.split('.').length - 1]) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase();
+    if (!endString)
+        return '';
+    if (endString.includes(enums_1.EnumFilePrefix.Archive))
+        return (0, exports.getFileType)(str.split(enums_1.EnumFilePrefix.Archive)[0]);
+    return endString;
+};
+exports.getFileType = getFileType;
+/**
+ * Добавляем полную спецификацию к объекту
+ * 1. Drop: Если в передаваемом json_list мы не находим елемент из уже имеющегося массива
+ * 		object_arr - удаляем этот элемент из массима object_arr
+ * 2. Create: Если в передаваемом json_list мы не найдем в object_arr - добавляем его в object_arr
+ *
+ * @param jsonb_list
+ * @param entitieNames  'materials'
+ * @param entities  Array<Material>
+ * @param parent
+ * @returns
+ */
+function addListSpetificationJSONB(jsonbList, entitieNames, parent, transaction) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entities = parent[entitieNames];
+        if (!(jsonbList === null || jsonbList === void 0 ? void 0 : jsonbList.length) || !entities)
+            return yield returnNull();
+        try {
+            const listArray = jsonbList.length ? jsonbList.slice(0) : [];
+            const copyParentArr = entities.length ? entities.slice(0) : [];
+            for (const listArrayItem of listArray) {
+                const findIndex = copyParentArr.findIndex(item => item.id === listArrayItem.id);
+                if (findIndex !== -1) {
+                    copyParentArr.splice(findIndex, 1);
+                }
+                else {
+                    yield parent.$add(entitieNames, listArrayItem.id, { transaction });
+                }
+            }
+            for (const parentItemToDelete of copyParentArr) {
+                yield parent.$remove(entitieNames, parentItemToDelete.id, {
+                    transaction
+                });
+            }
+            return jsonbList;
+        }
+        catch (err) {
+            console.error(err);
+            return [];
+        }
+        function returnNull() {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (const item of entities || []) {
+                    yield parent.$remove(entitieNames, item.id, { transaction });
+                }
+                return [];
+            });
+        }
+    });
+}
+/**
+ * Обновляем актуальные данные для Спецификации объекта
+ * @param object
+ * @param cbedRepo
+ * @param detalRepo
+ * @param materialRepo
+ * @param transaction
+ * @returns
+ */
+function updateDataForSpetification(object, cbedRepo, detalRepo, materialRepo, transaction) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const arr = [
+                ...object.listCbed.map((item) => (Object.assign(Object.assign({}, item), { type: 'listCbed' }))),
+                ...object.listDetal.map((item) => (Object.assign(Object.assign({}, item), { type: 'listDetal' }))),
+                ...object.listPokDet.map((item) => (Object.assign(Object.assign({}, item), { type: 'listPokDet' }))),
+                ...object.materialList.map((item) => (Object.assign(Object.assign({}, item), { type: 'materialList' })))
+            ];
+            const newSpetification = {
+                listCbed: [],
+                listDetal: [],
+                listPokDet: [],
+                materialList: []
+            };
+            for (const item of arr) {
+                let repository;
+                let arrays;
+                switch (item.type) {
+                    case 'listCbed':
+                        arrays = 'listCbed';
+                        repository = cbedRepo;
+                        break;
+                    case 'listDetal':
+                        arrays = 'listDetal';
+                        repository = detalRepo;
+                        break;
+                    case 'listPokDet':
+                        arrays = 'listPokDet';
+                        repository = materialRepo;
+                        break;
+                    case 'materialList':
+                        arrays = 'materialList';
+                        repository = materialRepo;
+                        break;
+                    default:
+                        continue;
+                }
+                const izd = yield repository.findByPk(item.id, { transaction });
+                if (!arrays || !izd)
+                    continue;
+                if (izd.articl)
+                    item.articl = izd.articl;
+                if (izd.name)
+                    item.name = izd.name;
+                newSpetification[arrays].push(item);
+            }
+            for (const key in newSpetification) {
+                newSpetification[key] = newSpetification[key].map(
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                (_a) => {
+                    var { type } = _a, rest = __rest(_a, ["type"]);
+                    return rest;
+                });
+            }
+            if (object.listCbed)
+                object.listCbed = newSpetification.listCbed;
+            if (object.listDetal)
+                object.listDetal = newSpetification.listDetal;
+            if (object.listPokDet)
+                object.listPokDet = newSpetification.listPokDet;
+            if (object.materialList)
+                object.materialList = newSpetification.materialList;
+            return object;
+        }
+        catch (err) {
+            console.error(err);
+        }
+    });
+}
+/**
+ * Функция получает 2 массива типа number[] и возвращает только различающиеся числа обоих массивов
+ * returnOnlyDifferentData([1,2,3,4,5],[1,2,3,6,7]) -> [4, 5, 6, 7]
+ */
+function returnOnlyDifferentData(firstArr, secondArray) {
+    const arrToCheck = Array.from(new Set(firstArr.concat(secondArray)));
+    const firstArrToCheck = new Set(firstArr);
+    const secondArrToCheck = new Set(secondArray);
+    const resultArray = arrToCheck.filter(arrItem => !firstArrToCheck.has(arrItem) || !secondArrToCheck.has(arrItem));
+    return resultArray;
+}
+function returnDeletedSpecificationItems(oldArr, newArr) {
+    const newArrIdsSet = new Set(newArr.map(specificationItem => specificationItem.id));
+    const result = [];
+    for (const oldArritem of oldArr) {
+        if (!newArrIdsSet.has(oldArritem.id))
+            result.push(oldArritem);
+    }
+    return result;
+}
+/**
+ * Функция получает 2 массива типа EntityCommonSpecificationArray и возвращает только новые или измененные идентификаторы
+ */
+function returnOnlyDifferentListData(oldArr, newArr) {
+    const differentIds = returnOnlyDifferentData(oldArr.map(item => item.id), newArr.map(item => item.id));
+    const resultArray = new Set(differentIds.slice(0));
+    const arrToCheck = Array.from(new Set(oldArr.concat(newArr))).filter(item => !resultArray.has(item.id));
+    for (const itemToCheck of arrToCheck) {
+        const itemInNewArr = newArr.find(newArrItem => newArrItem.id === itemToCheck.id);
+        const itemInOldArr = oldArr.find(oldArrItem => oldArrItem.id === itemToCheck.id);
+        if ((itemInNewArr === null || itemInNewArr === void 0 ? void 0 : itemInNewArr.quantity) !== (itemInOldArr === null || itemInOldArr === void 0 ? void 0 : itemInOldArr.quantity) &&
+            !resultArray.has(itemToCheck.id)) {
+            resultArray.add(itemToCheck.id);
+        }
+    }
+    return Array.from(resultArray);
+}
+/**
+ * Функция получает значение переданной характеристики или берет дефолтное значение
+ * @param characteristics
+ * @param defaultValue
+ * @param key
+ * @returns
+ */
+const characteristicValue = (characteristics, defaultValue, key) => {
+    var _a, _b;
+    return ((_a = characteristics[key]) === null || _a === void 0 ? void 0 : _a.used)
+        ? (_b = characteristics[key]) === null || _b === void 0 ? void 0 : _b.znach
+        : defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue[key];
+};
+/**
+ * Функция формирует объект характеристик детали из переданного материала
+ * @param material
+ * @param defaultValue
+ * @returns
+ */
+const useWorkpieceCharacterizationItems = (material, defaultValue) => {
+    var _a, _b, _c, _d;
+    const result = {};
+    for (const characteristicKey of Object.keys(((_a = material === null || material === void 0 ? void 0 : material.typeMaterial) === null || _a === void 0 ? void 0 : _a.characteristics) || [])) {
+        if (((_b = material === null || material === void 0 ? void 0 : material.typeMaterial) === null || _b === void 0 ? void 0 : _b.characteristics)[characteristicKey].znach) {
+            result[characteristicKey] = characteristicValue(material.characteristics, defaultValue, characteristicKey);
+        }
+    }
+    if ((_d = (_c = material === null || material === void 0 ? void 0 : material.characteristics) === null || _c === void 0 ? void 0 : _c['density']) === null || _d === void 0 ? void 0 : _d.znach) {
+        result.density = material === null || material === void 0 ? void 0 : material.characteristics['density'].znach;
+    }
+    result.mass = (defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue['mass']) || 0;
+    result.trash = (defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue['trash']) || 0;
+    return result;
+};
+exports.useWorkpieceCharacterizationItems = useWorkpieceCharacterizationItems;
+/**
+ * Сортирует операции по idx и полпускает операции в архиве
+ * @param izd
+ */
+function sortOperationsByIdx(izd, isBan = false) {
+    var _a, _b;
+    if ((izd === null || izd === void 0 ? void 0 : izd.techProcesses) && ((_b = (_a = izd.techProcesses) === null || _a === void 0 ? void 0 : _a.operations) === null || _b === void 0 ? void 0 : _b.length)) {
+        const tp = izd.techProcesses;
+        tp.operations = tp.operations.sort((a, b) => a.idx - b.idx);
+        // sort Operations and Operations BAN
+        const operations = [];
+        for (const operation of tp.operations) {
+            if (operation.ban === false || isBan)
+                operations.push(operation);
+        }
+        izd.techProcesses.operations = operations;
+    }
+    return izd;
+}
+/**
+ * Функция проверяет, является ли строка переменной типа bool
+ * @param stringBoolean
+ * @returns
+ */
+const strIsBoolean = (stringBoolean) => {
+    if (!stringBoolean)
+        return false;
+    try {
+        const val = JSON.parse(stringBoolean);
+        return typeof val === 'boolean';
+    }
+    catch (err) {
+        console.error(err);
+        return false;
+    }
+};
+exports.strIsBoolean = strIsBoolean;
+/**
+ * Функция парсит строку в булево значение
+ * @param stringBoolean
+ * @returns
+ */
+const parseBoolean = (stringBoolean) => {
+    try {
+        if ((0, exports.strIsBoolean)(stringBoolean))
+            return JSON.parse(stringBoolean);
+    }
+    catch (err) {
+        console.error(err);
+        return false;
+    }
+};
+exports.parseBoolean = parseBoolean;
+const sleep = (seconds) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield new Promise(resolve => setTimeout(resolve, seconds));
+});
+exports.sleep = sleep;
+/**
+ * Рекурсивная функция, обходит дерево и складывает все объекты в общую кучу
+ * @param arr
+ * @returns
+ */
+const getOnCommonListChildrens = (arr) => {
+    let cbedsArr = [];
+    let detalsArr = [];
+    let materialsArr = [];
+    function getRecursive(arrays) {
+        var _a, _b, _c;
+        for (const item of arrays) {
+            if ((_a = item.materials) === null || _a === void 0 ? void 0 : _a.length) {
+                for (const material of item.materials) {
+                    const findByParent = materialsArr.find(existMaterial => material.parent_id === existMaterial.parent_id &&
+                        material.parent_type === existMaterial.parent_type);
+                    if (item.count_to_needs && !findByParent)
+                        material.count_to_needs =
+                            (material.count_to_needs || 1) * item.count_to_needs;
+                }
+                materialsArr = materialsArr.concat(item.materials);
+            }
+            if ((_b = item.detals) === null || _b === void 0 ? void 0 : _b.length) {
+                for (const detal of item.detals || []) {
+                    // Если деталь с одним и темже родителем - не нужно заново считать потребность
+                    const findByParent = detalsArr.find(existDetal => detal.parent_id === existDetal.parent_id &&
+                        detal.parent_type === existDetal.parent_type);
+                    if (item.count_to_needs && !findByParent)
+                        detal.count_to_needs =
+                            (detal.count_to_needs || 1) * item.count_to_needs;
+                    const { materials } = detal;
+                    if (!materials || findByParent)
+                        continue;
+                    materials.forEach((el) => {
+                        if (detal.count_to_needs)
+                            el.count_to_needs = detal.count_to_needs;
+                    });
+                    materialsArr = materialsArr.concat(materials);
+                }
+                detalsArr = detalsArr.concat(item.detals);
+            }
+            if ((_c = item.cbeds) === null || _c === void 0 ? void 0 : _c.length) {
+                for (const cbed of item.cbeds) {
+                    const findByParent = cbedsArr.find(existCbed => cbed.parent_id === existCbed.parent_id &&
+                        cbed.parent_type === existCbed.parent_type);
+                    if (item.count_to_needs && !findByParent) {
+                        cbed.count_to_needs =
+                            (cbed.count_to_needs || 1) * item.count_to_needs;
+                    }
+                }
+                cbedsArr = cbedsArr.concat(item.cbeds);
+                getRecursive(item.cbeds);
+            }
+        }
+    }
+    getRecursive(arr);
+    return {
+        allCbeds: cbedsArr,
+        allDetals: detalsArr,
+        allMaterials: materialsArr
+    };
+};
+exports.getOnCommonListChildrens = getOnCommonListChildrens;
+/**
+ * Функция добавляет ключи, указывающие родительские атрибуты к переданной сущности
+ * @param childrens
+ * @param parent
+ * @param parentType
+ * @returns
+ */
+function appendedParentAttr(childrens, parent, parentType) {
+    return childrens.map(el => {
+        el.parent_name = parent.name;
+        el.parent_designation = parent.designation;
+        el.parent_id = parent.id;
+        if (parentType)
+            el.parent_type = parentType;
+        return el;
+    });
+}
+/**
+ * Возвращаем из массива с дубликатами новый массив с уникальными атрибутами,
+ * отфильтрованный по переданному атрибуту.
+ *
+ * при указании поля addUpByField - складывает поля по указанному атрибуту
+ * @param arr
+ * @param filtreAttr
+ * @param addUpByField
+ * @returns
+ */
+const removeArrDublicateByAttr = (arr, filtreAttr = 'id') => {
+    const uniqueItems = [];
+    const usedValues = new Set();
+    for (const item of arr) {
+        if (!item || !item[filtreAttr])
+            continue;
+        const attrValue = item[filtreAttr];
+        if (!usedValues.has(attrValue)) {
+            uniqueItems.push(item);
+            usedValues.add(attrValue);
+        }
+        else {
+            const findEntity = uniqueItems.find(entity => entity[filtreAttr] === item[filtreAttr]);
+            if (findEntity) {
+                findEntity.count_to_needs += Number((item === null || item === void 0 ? void 0 : item.count_to_needs) || 0);
+                findEntity.count_to_obj += Number((item === null || item === void 0 ? void 0 : item.count_to_obj) || 0);
+            }
+        }
+    }
+    return uniqueItems;
+};
+exports.removeArrDublicateByAttr = removeArrDublicateByAttr;
+/**
+ * Складываем значения по полю в списке потомков по id
+ * @param entities
+ * @param countField
+ * @returns
+ */
+const countUniqueValueChildren = (entities, countField) => {
+    const uniqueItems = [];
+    const usedValues = new Set();
+    for (const item of entities) {
+        if (usedValues.has(item.id)) {
+            const findEntity = uniqueItems.find(entity => item.id === entity.id);
+            const parentDublicates = findEntity.parents.find((parent) => item.parent_id === parent.parent_id &&
+                item.parent_type === parent.parent_type);
+            if (parentDublicates)
+                continue;
+            findEntity.parents.push({
+                parent_id: item.parent_id,
+                parent_type: item.parent_type
+            });
+            countField.forEach(field => (findEntity[field] += Number(item[field])));
+        }
+        else {
+            usedValues.add(item.id);
+            const newItem = {
+                id: item.id,
+                parents: [
+                    {
+                        parent_id: item.parent_id,
+                        parent_type: item.parent_type
+                    }
+                ]
+            };
+            countField.forEach(field => (newItem[field] = Number(item[field])));
+            uniqueItems.push(newItem);
+        }
+    }
+    return uniqueItems;
+};
+exports.countUniqueValueChildren = countUniqueValueChildren;
+/**
+ * Функция формирует графовый объект с потомками сущности
+ * @param data
+ * @returns
+ */
+const countChildrensRelative = (data) => {
+    var _a;
+    const { relativeEntity, relativeEntityType, isAppendedMaterials: isAppendedMaterials = false, detals, cbeds } = data;
+    const materials = ((_a = data === null || data === void 0 ? void 0 : data.materials) === null || _a === void 0 ? void 0 : _a.length) ? data.materials : [];
+    const countChildrens = (relative, relativeType) => {
+        var _a, _b, _c, _d;
+        const relativeNeeds = (relative === null || relative === void 0 ? void 0 : relative.needs) || 1;
+        if (relativeType !== enums_1.IzdType.detal) {
+            relative.cbedGraph = [];
+            relative.detalsGraph = [];
+        }
+        if (isAppendedMaterials)
+            relative.materialGraph = [];
+        if (relative === null || relative === void 0 ? void 0 : relative.listCbed) {
+            relative.cbeds =
+                ((_a = relative === null || relative === void 0 ? void 0 : relative.listCbed) === null || _a === void 0 ? void 0 : _a.map((listCbedItem) => {
+                    const foundedCbed = cbeds.find(cbed => listCbedItem.id === cbed.id);
+                    return Object.assign(Object.assign({}, foundedCbed), { count_to_obj: listCbedItem.quantity, count_to_needs: relativeNeeds * listCbedItem.quantity, needs: relativeNeeds * listCbedItem.quantity, parent_id: relative.id, parent_type: relativeType, parent_designation: (relative === null || relative === void 0 ? void 0 : relative.designation) || '-', parent_name: (relative === null || relative === void 0 ? void 0 : relative.name) || '-' });
+                })) || [];
+            relative.cbedGraph = [...relative.cbeds];
+        }
+        if (relative === null || relative === void 0 ? void 0 : relative.listDetal) {
+            relative.detals =
+                ((_b = relative === null || relative === void 0 ? void 0 : relative.listDetal) === null || _b === void 0 ? void 0 : _b.map((listDetalItem) => {
+                    const foundedDetal = detals.find(detal => listDetalItem.id === detal.id);
+                    return Object.assign(Object.assign({}, foundedDetal), { count_to_obj: listDetalItem.quantity, count_to_needs: relativeNeeds * listDetalItem.quantity, needs: relativeNeeds * listDetalItem.quantity, parent_id: relative.id, parent_type: relativeType, parent_designation: (relative === null || relative === void 0 ? void 0 : relative.designation) || '-', parent_name: (relative === null || relative === void 0 ? void 0 : relative.name) || '-' });
+                })) || [];
+            relative.detalsGraph = [...relative.detals];
+        }
+        if (isAppendedMaterials) {
+            /**
+             * @todo если в одной детали материал будет и заготовкой, и в спецификации, то
+             * в materialGraph этот материал продублируется с одинаковым родителем,
+             * хотя должен был увеличиться needs.
+             * На unicalMaterialNeeds это не влияет. Там подсчеты верны
+             */
+            const concatedMaterialLists = ((relative === null || relative === void 0 ? void 0 : relative.materialList) || [])
+                .concat((relative === null || relative === void 0 ? void 0 : relative.listPokDet) || [], (relative === null || relative === void 0 ? void 0 : relative.mat_zag) ? { id: relative === null || relative === void 0 ? void 0 : relative.mat_zag, quantity: 1 } : null, (relative === null || relative === void 0 ? void 0 : relative.mat_zag_zam)
+                ? { id: relative === null || relative === void 0 ? void 0 : relative.mat_zag_zam, quantity: 1 }
+                : null)
+                .filter(Boolean);
+            relative.materials = concatedMaterialLists.map((listMaterialItem) => {
+                const foundedMaterials = materials.find(material => listMaterialItem.id === material.id);
+                return Object.assign(Object.assign({}, foundedMaterials), { count_to_obj: listMaterialItem.quantity, count_to_needs: relativeNeeds * listMaterialItem.quantity, needs: relativeNeeds * listMaterialItem.quantity, parent_id: relative.id, parent_type: relativeType, parent_designation: (relative === null || relative === void 0 ? void 0 : relative.designation) || '-', parent_name: (relative === null || relative === void 0 ? void 0 : relative.name) || '-' });
+            });
+            relative.materialGraph = [...relative.materials];
+        }
+        if ((_c = relative === null || relative === void 0 ? void 0 : relative.listCbed) === null || _c === void 0 ? void 0 : _c.length) {
+            for (const cbed of relative.cbeds) {
+                countChildrens(cbed, enums_1.IzdType.cbed);
+                relative.cbedGraph = [...relative.cbedGraph, ...cbed.cbedGraph];
+                relative.detalsGraph = [...relative.detalsGraph, ...cbed.detalsGraph];
+                if (isAppendedMaterials)
+                    relative.materialGraph = [
+                        ...relative.materialGraph,
+                        ...cbed.materialGraph
+                    ];
+            }
+        }
+        if ((_d = relative === null || relative === void 0 ? void 0 : relative.listDetal) === null || _d === void 0 ? void 0 : _d.length) {
+            for (const detal of relative.detals) {
+                if (isAppendedMaterials) {
+                    countChildrens(detal, enums_1.IzdType.detal);
+                    relative.materialGraph = [
+                        ...relative.materialGraph,
+                        ...detal.materialGraph
+                    ];
+                }
+            }
+        }
+        if (relativeType !== enums_1.IzdType.detal) {
+            const unicalDetalNeedsObject = {};
+            const unicalCbedNeedsObject = {};
+            for (const cbed of relative.cbedGraph) {
+                unicalCbedNeedsObject[cbed.id] = (unicalCbedNeedsObject === null || unicalCbedNeedsObject === void 0 ? void 0 : unicalCbedNeedsObject[cbed.id])
+                    ? unicalCbedNeedsObject[cbed.id] + cbed.needs
+                    : cbed.needs;
+            }
+            for (const detal of relative.detalsGraph) {
+                unicalDetalNeedsObject[detal.id] = (unicalDetalNeedsObject === null || unicalDetalNeedsObject === void 0 ? void 0 : unicalDetalNeedsObject[detal.id])
+                    ? unicalDetalNeedsObject[detal.id] + detal.needs
+                    : detal.needs;
+            }
+            relative.unicalDetalNeeds = Object.keys(unicalDetalNeedsObject)
+                .map(key => {
+                return { id: Number(key), needs: unicalDetalNeedsObject[key] };
+            })
+                .filter(entity => entity.id);
+            relative.unicalCbedNeeds = Object.keys(unicalCbedNeedsObject)
+                .map(key => {
+                return { id: Number(key), needs: unicalCbedNeedsObject[key] };
+            })
+                .filter(entity => entity.id);
+        }
+        if (isAppendedMaterials) {
+            const unicalMaterialNeedsObject = {};
+            for (const material of relative.materialGraph) {
+                unicalMaterialNeedsObject[material.id] = (unicalMaterialNeedsObject === null || unicalMaterialNeedsObject === void 0 ? void 0 : unicalMaterialNeedsObject[material.id])
+                    ? unicalMaterialNeedsObject[material.id] + material.needs
+                    : material.needs;
+            }
+            relative.unicalMaterialNeeds = Object.keys(unicalMaterialNeedsObject)
+                .map(key => {
+                return { id: Number(key), needs: unicalMaterialNeedsObject[key] };
+            })
+                .filter(entity => entity.id);
+        }
+    };
+    const copyRelativeEntity = copyObject(relativeEntity);
+    countChildrens(copyRelativeEntity, relativeEntityType);
+    return copyRelativeEntity;
+};
+exports.countChildrensRelative = countChildrensRelative;
+/**
+ * Функция ищет отсутствующие идентификаторы в графомо объекте
+ * @param data
+ * @returns
+ */
+const checkMissingEntity = (data) => {
+    const cbedIds = new Set(data.cbeds.map(cbed => cbed.id));
+    const detalIds = new Set(data.detals.map(detal => detal.id));
+    const resultMissingIds = {
+        cbedIds: [],
+        detalIds: []
+    };
+    const checkIdExisting = (entity) => {
+        for (const listCbedItem of (entity === null || entity === void 0 ? void 0 : entity.listCbed) || []) {
+            if (!cbedIds.has(listCbedItem.id)) {
+                resultMissingIds.cbedIds.push(listCbedItem.id);
+            }
+        }
+        for (const listDetalItem of (entity === null || entity === void 0 ? void 0 : entity.listDetal) || []) {
+            if (!detalIds.has(listDetalItem.id)) {
+                resultMissingIds.detalIds.push(listDetalItem.id);
+            }
+        }
+    };
+    if (data.product) {
+        checkIdExisting(data.product);
+    }
+    for (const cbed of data.cbeds) {
+        checkIdExisting(cbed);
+    }
+    return resultMissingIds;
+};
+exports.checkMissingEntity = checkMissingEntity;
+/**
+ * Удаляет выделенный класс у переданного объекта и возвращает для нового
+ * @param {*} elast
+ * @param {*} classs
+ * @param {*} classs
+ * @returns
+ */
+function eSelectSpan(elast, eNow, classs = 'td-row-all') {
+    if (elast && (elast === null || elast === void 0 ? void 0 : elast.classList))
+        elast.classList.remove(classs);
+    elast = eNow;
+    if (elast && (elast === null || elast === void 0 ? void 0 : elast.classList))
+        elast.classList.add(classs);
+    return elast;
+}
+/**
+ * Получает объект с заказом со склада и заказом покупателя
+ * и возвращает ближайшую планируемую дату отгрузки
+ */
+function compareShipmentWorkingDate(entity) {
+    var _a;
+    if (!entity)
+        return '-';
+    const shipmentDateUrgency = (_a = entity === null || entity === void 0 ? void 0 : entity.shipment) === null || _a === void 0 ? void 0 : _a.date_shipments;
+    return shipmentDateUrgency ? (0, exports.dateToFormat)(shipmentDateUrgency) : '-';
+}
+/**
+ * Возвращает видоизмененный объект с позицией на заказ или приход
+ * @param {*} position
+ * @param {*} positionList
+ * @returns
+ */
+function posToDeliveries(position, positionList) {
+    if (!position)
+        return null;
+    // Проверка на дублеэ
+    for (const item of positionList) {
+        if (item.id == position.id && item.type == position.type)
+            return null;
+    }
+    try {
+        const units_type = (0, edizm_1.getFirstUnits)(position);
+        const units_measurement = (position === null || position === void 0 ? void 0 : position.units_measurement)
+            ? position.units_measurement.filter((el) => el.used)
+            : [{ units_type, used: true }];
+        return {
+            id: position.id,
+            designation: '',
+            name: position.name,
+            type: position.type ? position.type : 'mat',
+            units_type,
+            kol: position.shipments_kolvo ? position.shipments_kolvo : 1,
+            sum: 0,
+            description: '',
+            units_measurement: units_measurement
+        };
+    }
+    catch (e) {
+        console.error(e, 'Err!');
+    }
+}
+const returnTypePosition = (type) => ({
+    [types_1.TypeCategoryEnum.material]: ['Материал', 'Мат'],
+    [types_1.TypeCategoryEnum.tools]: ['Инструмент', 'Инстр.'],
+    [types_1.TypeCategoryEnum.equipment]: ['Оборудование', 'Об.'],
+    [types_1.TypeCategoryEnum.inventary]: ['Инвентарь', 'Инв.']
+})[type];
+exports.returnTypePosition = returnTypePosition;
+/**
+ * Функция копирует строку
+ * @param str
+ * @param len
+ * @returns
+ */
+function sliceName(str, len = 22) {
+    if (!str)
+        return '-';
+    if (str.length > len) {
+        str = str.slice(0, 32);
+        str += '...';
+    }
+    return str;
+}
+/**
+ * Дефицит расчитывается как
+ * Кол-во на складе - (минимальный остаток + заказанное кол-во + дефицит по заказам склада)
+ * @param {*} izd
+ * @param {*} kol
+ * @returns
+ */
+function returnDificit(izd, kol) {
+    return lessPlusNum(kol - (izd.min_remaining + (izd.deficit_by_sclad || 0)));
+}
+/**
+ * Функция открывает переданный URL в новой вкладке
+ * @param url
+ */
+function openInNewTab(url) {
+    window.open(url, '_blank');
+}
+/**
+ *
+ * @param event
+ * @param number
+ * получает евент и отправляет булеву переменную в зависимости от того,
+ * является ли его значение положительным целым числом
+ */
+const isValidNumber = (event, number) => {
+    const value = event.target.value;
+    const isValid = /^\d+$/.test(value);
+    if (!isValid || Number(value) < 1) {
+        event.target.value = number;
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+exports.isValidNumber = isValidNumber;
+const FORMAT_IMG = [
+    'bmp',
+    'gif',
+    'jpg',
+    'png',
+    'pds',
+    'tif',
+    'odg',
+    'jpeg',
+    'eps',
+    'pict',
+    'pcx',
+    'ico',
+    'webp'
+];
+const FORMAT_MOVI = ['mp4', 'webm', 'ogv'];
+/**
+ * Обычную дату преобразует к читаемому виду
+ * @param {*} DAT
+ * @returns {date: '29.11.2022', time: '16:39:16'}
+ */
+const getReversDate = (DAT) => {
+    if (!DAT)
+        return { date: '-', time: '-' };
+    const date = DAT.split('T')[0]
+        .replaceAll('-', '.')
+        .split('.')
+        .reverse()
+        .join('.');
+    const time = DAT.split('T')[1].split('.')[0];
+    return { date, time };
+};
+exports.getReversDate = getReversDate;
+/**
+ * Функция проверяет, является ли сущность фотографией
+ * @param path
+ * @returns
+ */
+const isImage = (path) => {
+    if (!path)
+        return false;
+    const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|svg)$/i;
+    return imageExtensions.test(path);
+};
+exports.isImage = isImage;
+/**
+ * Проверяет тип контента и формирует ссылку на предпросмотр
+ * @param {*} input
+ * @param {*} cb
+ * @param {*} checkTypes
+ * @returns
+ */
+const photoPreloadUrl = (input, cb, checkTypes = false) => {
+    if (!input || !input.name)
+        return 0;
+    let typeFile = input.name
+        .split('.')[input.name.split('.').length - 1].toLowerCase();
+    if (typeFile.indexOf('_archive_v', 1) != -1)
+        typeFile = typeFile.split('_archive_v')[0];
+    let type;
+    for (const imgType of FORMAT_IMG) {
+        if (typeFile == imgType)
+            type = 'img';
+    }
+    for (const movi of FORMAT_MOVI) {
+        if (movi == typeFile)
+            type = 'movi';
+    }
+    if (type != 'img' && type != 'movi')
+        return cb({ type: 'doc', typename: typeFile });
+    if (type == 'img' && checkTypes)
+        return cb({ type: 'img', typename: typeFile });
+    if (type == 'movi' && checkTypes)
+        return cb({ type, typename: typeFile });
+    if (type == 'movi')
+        return cb({ type, typename: typeFile });
+    const reader = new FileReader();
+    reader.onload = function (e) {
+        if (e && e.target && e.target.result)
+            return cb({ type, url: e.target.result });
+    };
+    reader.readAsDataURL(input);
+};
+exports.photoPreloadUrl = photoPreloadUrl;
+const addNull = (str) => (str.length <= 1 ? '0' + str : str);
+/**
+ * приводит дату к формату '22.05.2024'
+ * @param date
+ * @returns
+ */
+const dateToFormat = (date) => {
+    return date
+        ? new Date(date).toLocaleString('ru-RU', { timeZone: 'UTC' }).split(',')[0]
+        : '-';
+};
+exports.dateToFormat = dateToFormat;
+/**
+ * Конвертирует все строковые значения объекта в числовые
+ */
+const convertStringValuesToNumbers = (entity) => {
+    const result = {};
+    for (const key in entity) {
+        if (Object.prototype.hasOwnProperty.call(entity, key)) {
+            const value = entity[key];
+            if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value)) {
+                result[key] = (0, exports.convertStringValuesToNumbers)(value);
+            }
+            else if (typeof value === 'string' &&
+                !isNaN(Number(value)) &&
+                value.trim() !== '') {
+                result[key] = Number(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+};
+exports.convertStringValuesToNumbers = convertStringValuesToNumbers;
+/**
+ * функция приводит дату к формату timestamp
+ * @param  date = '22.05.2024'
+ * @param isStartDay - нужно ли получать дату от 12 часов дня
+ * @returns 2024-05-22 00:00:00.000+03'
+ */
+const dateToTimestampFormat = (date, isStartDay = true) => {
+    if (date.length === 10) {
+        const formattedDate = date.split('.').reverse().join('-');
+        return `${formattedDate} ${isStartDay ? '12' : '01'}:00:00.000+03`;
+    }
+    else {
+        const parsedDate = new Date(date);
+        if (!isStartDay) {
+            parsedDate.setHours(6, 0, 0, 0);
+        }
+        return parsedDate.toISOString().replace('T', ' ').replace('Z', '+03');
+    }
+};
+exports.dateToTimestampFormat = dateToTimestampFormat;
+/**
+ * Приводим дату к формату
+ * new Date() => DD.MM.YYYY
+ * @param {*} dat
+ * @returns
+ */
+const dataFormat = (dat = new Date()) => {
+    const Day = addNull(String(dat.getUTCDate()));
+    const Month = addNull(String(dat.getMonth() + 1));
+    const Yeard = dat.getFullYear();
+    const splitData = `${Day}.${Month}.${Yeard}`;
+    return splitData;
+};
+exports.dataFormat = dataFormat;
+/**
+ * Функция преобразовывает дату в формат DD:MM:YYYY HH:MM:SS
+ * @param dat
+ * @returns
+ */
+const parseDate = (dat = new Date()) => {
+    const Year = dat.getFullYear();
+    const Mount = addNull(String(dat.getMonth() + 1));
+    const Weekly = addNull(String(dat.getDate()));
+    const Hours = addNull(String(dat.getHours()));
+    const Minute = addNull(String(dat.getMinutes()));
+    const Seconds = addNull(String(dat.getSeconds()));
+    const splitTime = `${Weekly}.${Mount}.${Year} ${Hours}:${Minute}:${Seconds}`;
+    return splitTime;
+};
+exports.parseDate = parseDate;
+/**
+ *  Сравнения дат. типа: '2022-01-20 00:00:00.000+03'
+ *  В зависимости от условия выдает тип Boolean.
+ * @param {*} one_date
+ * @param {*} two_date
+ * @param {*} operation
+ * @returns boolean
+ */
+const comparisonTimestamp = (one_date = new Date(), two_date = new Date(), operation = '==') => {
+    const d1 = (0, exports.dateToTimestampFormat)(`${one_date}`);
+    const d2 = (0, exports.dateToTimestampFormat)(`${two_date}`);
+    let result;
+    switch (operation) {
+        case '==':
+            result = Date.parse(d1) == Date.parse(d2);
+            break;
+        case '<':
+            result = Date.parse(d1) < Date.parse(d2);
+            break;
+        case '>':
+            result = Date.parse(d1) > Date.parse(d2);
+            break;
+        case '<=':
+            result = Date.parse(d1) <= Date.parse(d2);
+            break;
+        case '>=':
+            result = Date.parse(d1) >= Date.parse(d2);
+            break;
+        case '!=':
+            result = Date.parse(d1) != Date.parse(d2);
+            break;
+        default:
+            return false;
+    }
+    return result;
+};
+exports.comparisonTimestamp = comparisonTimestamp;
+/**
+ *  Сравнения дат. типа: '10.03.2022'
+ *  В зависимости от условия выдает тип Boolean.
+ * @param {*} one_date
+ * @param {*} two_date
+ * @param {*} operation
+ * @returns boolean
+ */
+const comparison = (one_date = new Date().toLocaleDateString('ru-RU'), two_date = new Date().toLocaleDateString('ru-RU'), operation = '==') => {
+    const d1 = utfDate(one_date);
+    const d2 = utfDate(two_date);
+    function utfDate(d) {
+        if (!d)
+            return '';
+        const ds = d.split('.').reverse().join('-') + 'T10:10:10Z';
+        return ds;
+    }
+    let result;
+    switch (operation) {
+        case '==':
+            result = Date.parse(d1) == Date.parse(d2);
+            break;
+        case '<':
+            result = Date.parse(d1) < Date.parse(d2);
+            break;
+        case '>':
+            result = Date.parse(d1) > Date.parse(d2);
+            break;
+        case '<=':
+            result = Date.parse(d1) <= Date.parse(d2);
+            break;
+        case '>=':
+            result = Date.parse(d1) >= Date.parse(d2);
+            break;
+        case '!=':
+            result = Date.parse(d1) != Date.parse(d2);
+            break;
+        default:
+            return false;
+    }
+    return result;
+};
+exports.comparison = comparison;
+/**
+ * Преобразует строку DD.MM.YYYY в формат даты new Date()
+ * @param {*} date
+ * @returns
+ */
+const toFormatString = (date) => {
+    if (!date || typeof date != 'string')
+        return '';
+    const spl = date === null || date === void 0 ? void 0 : date.split('.');
+    return `${spl[2]}-${spl[1]}-${spl[0]}T10:20:30Z`;
+};
+exports.toFormatString = toFormatString;
+/**
+ * Возвращает разницу в днях между датами
+ * @param date1
+ * @param date2
+ * @returns
+ */
+const dateDifference = (date1, date2) => {
+    if (!date2)
+        return 0;
+    const formatedFirstDate = date1 ? new Date(date1) : new Date();
+    const diffInMillis = new Date(date2).getTime() - new Date(formatedFirstDate).getTime();
+    const diffInDays = diffInMillis / (1000 * 60 * 60 * 24);
+    return Math.ceil(diffInDays);
+};
+exports.dateDifference = dateDifference;
+/**
+ *  Сортирует Задачи на отгрузку по дате планируемой отгрузки
+ *  по третьему параметру сортирует сверху вниз или наоборот
+ * @param {*} noSortArr
+ * @param {*} field
+ * @param {*} firstIs
+ * @returns
+ */
+const differencesShipments = (noSortArr, field = 'date_shipments', firstIs = true) => {
+    for (const ship of noSortArr) {
+        if (ship[field])
+            ship.difference = (0, exports.dateDifference)(undefined, ship[field]);
+        else
+            ship.difference = 0;
+    }
+    const arr = noSortArr.sort((a, b) => firstIs ? a.difference - b.difference : b.difference - a.difference);
+    return arr;
+};
+exports.differencesShipments = differencesShipments;
+const shipmentsNullOne = (item) => {
+    if (!item)
+        return item;
+    const str = item.split('от');
+    if (!str.length || str.length != 2)
+        return item;
+    if (str[0].indexOf('/', 0) === -1) {
+        str[0] += ' /0 ';
+        item = str[0] + str[1];
+    }
+    return item;
+};
+exports.shipmentsNullOne = shipmentsNullOne;
+/**
+ * Возвращает массив с пересечением переданных массивов
+ * @param arrays
+ * @returns
+ */
+const intersect = (...arrays) => {
+    return arrays.reduce((acc, curr) => {
+        const set = new Set(curr);
+        return acc.filter(x => set.has(x));
+    });
+};
+exports.intersect = intersect;