bx-rest 0.5.3 → 0.6.1

package/esm2022/services/navvy/extends/navvy-pag-base.mjs

@@ -0,0 +1,41 @@
+import { catchError, map } from 'rxjs/operators';
+import { BXRestMapResult, instanceOfiBXRestAnswerSuccess } from '../../../functions/mapResult';
+import { HttpBXServices } from '../../http/HttpBX';
+/**
+ * Грядущая повсеместная замена для NavvyPagNavBase
+ */
+export class NavvyPagBase {
+    constructor(url, param, map) {
+        this.url = url;
+        this.param = param;
+        this.map = map;
+        this.pageSize = 50; // стандартный размер страницы
+        this.http = new HttpBXServices();
+    }
+    resVanilla() {
+        return this.http.post(this.url, this.param);
+    }
+    mapForVanilla() {
+        return this.resVanilla()
+            .pipe(map(v => {
+            if (v && instanceOfiBXRestAnswerSuccess(v) && this.map) {
+                // Применяем this.map и явно приводим тип результата
+                const result = this.map(v.result);
+                return { ...v, ...{ result: result } };
+            }
+            return v;
+        }));
+    }
+    res() {
+        return this.mapAndError(this.resVanilla()).pipe(map(v => (v && this.map)
+            ? this.map(v)
+            : v));
+    }
+    mapAndError(request) {
+        return request.pipe(map(v => BXRestMapResult(v)), catchError((err) => {
+            console.error(err);
+            throw new Error((err.error) ? err.error : err);
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/navvy/navvy-alternative-pagination-navigation.mjs

@@ -0,0 +1,84 @@
+import { concatMap, from, last, mergeMap, shareReplay, throwError, toArray } from 'rxjs';
+import clone from 'just-clone';
+import { catchError, map } from 'rxjs/operators';
+import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+import * as qs from 'qs';
+import { BXRest } from '../../rest/base';
+/**
+ * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по
+ * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php
+ *
+ * не завершенный класс, работаем от частного к общему
+ */
+export class NavvyAlterPagNav extends NavvyPagBase {
+    resAll() {
+        let save = [];
+        return this.resultAllEnd()
+            .pipe(map(v => {
+            if (v) {
+                save.push(...v);
+            }
+            return save;
+        }), last(), shareReplay(1));
+    }
+    resultAllEnd() {
+        let BXRestClass = new BXRest();
+        // return  this.mapForVanillaEnd(this.func, this.param)
+        return this.resVanilla().pipe(mergeMap(items => {
+            if (items && instanceOfiBXRestAnswerSuccess(items)) {
+                if (items.total && items.next) {
+                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
+                    // Разделяем массив на блоки
+                    const chunks = [];
+                    for (let i = 0; i < count.length; i += this.pageSize) {
+                        chunks.push(count.slice(i, i + this.pageSize));
+                    }
+                    const batchRequests = chunks.map(chunk => {
+                        return BXRestClass.batch({
+                            halt: 1,
+                            cmd: chunk.map(i => {
+                                const param = clone(this.param);
+                                if (!param.PARAMS) {
+                                    param.PARAMS = {
+                                        NAV_PARAMS: {
+                                            iNumPage: 0,
+                                            nPageSize: 50
+                                        }
+                                    };
+                                }
+                                // Устанавливаем start в зависимости от индекса
+                                param.PARAMS.NAV_PARAMS.iNumPage = i + 2; // первая страница уже есть, старт со второй
+                                // Формируем строку запроса
+                                return this.http.getNameMethod(this.url)
+                                    + '?' + qs.stringify(param, { arrayFormat: 'brackets' });
+                            })
+                        });
+                    });
+                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
+                    toArray(), // Собирает все результаты в массив
+                    map(results => {
+                        const res = items.result;
+                        for (let result of results) {
+                            if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
+                                res.push(...result.result.result.map(i => i).flat());
+                            }
+                        }
+                        return (this.map) ?
+                            this.map(res)
+                            : res;
+                    }));
+                }
+            }
+            return this.mapResultForGetAll(items);
+        }), catchError(err => {
+            // this.snackBar.error("Проблемы с поточным получение затреканого времени")
+            console.error(err);
+            return throwError(() => err);
+        }));
+    }
+    mapResultForGetAll(items) {
+        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navvy-alternative-pagination-navigation.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/navvy/navvy-alternative-pagination-navigation.ts"],"names":[],"mappings":"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","sourcesContent":["import { concatMap, from, last, mergeMap, shareReplay, throwError, toArray } from 'rxjs'\r\nimport { iBXRestAnswer } from '../../typification/rest/base/answer'\r\nimport clone from 'just-clone'\r\nimport { catchError, map } from 'rxjs/operators'\r\nimport { ReturnTypeNavvy } from './navvy-support'\r\nimport { iBXRestAlternativePagination } from '../../typification/rest/base/api-pagination-bx'\r\nimport { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult'\r\nimport { NavvyPagBase } from './extends/navvy-pag-base'\r\nimport * as qs from 'qs'\r\nimport { BXRest } from '../../rest/base'\r\n\r\n/**\r\n * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по\r\n * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php\r\n *\r\n * не завершенный класс, работаем от частного к общему\r\n */\r\nexport class NavvyAlterPagNav<T, R, P extends iBXRestAlternativePagination> extends NavvyPagBase<T[], R[], P> {\r\n\r\n  resAll() {\r\n    let save: ReturnTypeNavvy<T, R>[] = []\r\n    return this.resultAllEnd()\r\n      .pipe(\r\n        map(v => {\r\n            if (v) {\r\n              save.push(...v as ReturnTypeNavvy<T, R>[])\r\n            }\r\n            return save\r\n          }\r\n        ),\r\n        last(),\r\n        shareReplay(1)\r\n      )\r\n  }\r\n\r\n  private resultAllEnd() {\r\n    let BXRestClass = new BXRest()\r\n    // return  this.mapForVanillaEnd(this.func, this.param)\r\n    return this.resVanilla().pipe(\r\n      mergeMap(\r\n        items => {\r\n          if (items && instanceOfiBXRestAnswerSuccess(items)) {\r\n            if (items.total && items.next) {\r\n              const count = [...Array(Math.floor(items.total / this.pageSize)).keys()]\r\n\r\n              // Разделяем массив на блоки\r\n              const chunks = []\r\n\r\n              for (let i = 0; i < count.length; i += this.pageSize) {\r\n                chunks.push(count.slice(i, i + this.pageSize))\r\n              }\r\n\r\n              const batchRequests = chunks.map(chunk => {\r\n                return BXRestClass.batch<T[][]>({\r\n                  halt: 1,\r\n                  cmd: chunk.map(i => {\r\n                    const param = clone(this.param)\r\n\r\n                    if (!param.PARAMS) {\r\n                      param.PARAMS = {\r\n                        NAV_PARAMS: {\r\n                          iNumPage: 0,\r\n                          nPageSize: 50\r\n                        }\r\n                      }\r\n                    }\r\n\r\n                    // Устанавливаем start в зависимости от индекса\r\n                    param.PARAMS!.NAV_PARAMS.iNumPage = i + 2 // первая страница уже есть, старт со второй\r\n\r\n                    // Формируем строку запроса\r\n                    return this.http.getNameMethod(this.url)\r\n                      + '?' + qs.stringify(param, {arrayFormat: 'brackets'})\r\n                  })\r\n                })\r\n              })\r\n\r\n              return from(batchRequests).pipe(\r\n                concatMap(request => request), // Выполняет запросы по очереди\r\n                toArray(), // Собирает все результаты в массив\r\n                map(results => {\r\n                  const res = items.result as T[]\r\n                  for (let result of results) {\r\n                    if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {\r\n                      res.push(...result.result.result.map(i => i).flat())\r\n                    }\r\n                  }\r\n\r\n                  return (this.map) ?\r\n                    this.map(res)\r\n                    : res\r\n                })\r\n              )\r\n            }\r\n          }\r\n\r\n          return this.mapResultForGetAll(items)\r\n        }\r\n      ),\r\n      catchError(err => {\r\n        // this.snackBar.error(\"Проблемы с поточным получение затреканого времени\")\r\n        console.error(err)\r\n        return throwError(() => err)\r\n      })\r\n    )\r\n  }\r\n\r\n  private mapResultForGetAll(items: iBXRestAnswer<T[]> | undefined) {\r\n    return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(\r\n      map(v => (v && this.map) ? this.map(v) : v)\r\n    ) : from([] as ReturnTypeNavvy<T, R>[])\r\n  }\r\n}\r\n"]}

package/esm2022/services/navvy/navvy-pag-nav-tasks.mjs

@@ -0,0 +1,78 @@
+import { concatMap, from, last, mergeMap, shareReplay, throwError, toArray } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import clone from 'just-clone';
+import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+import * as qs from 'qs';
+import { BXRest } from '../../rest/base';
+export class NavvyPagNavTasks extends NavvyPagBase {
+    constructor() {
+        super(...arguments);
+        this.save = [];
+    }
+    resAll() {
+        let save = [];
+        return this.resultAllEnd()
+            .pipe(map(v => {
+            if (v) {
+                save.push(...v);
+            }
+            return save;
+        }), last(), shareReplay(1));
+    }
+    resultAllEnd() {
+        let BXRestClass = new BXRest();
+        return this.resVanilla().pipe(mergeMap(items => {
+            if (items && instanceOfiBXRestAnswerSuccess(items)) {
+                this.save = [];
+                // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)
+                if (items.total && items.total > 50) {
+                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
+                    // Разделяем массив на блоки
+                    const chunks = [];
+                    for (let i = 0; i < count.length; i += this.pageSize) {
+                        chunks.push(count.slice(i, i + this.pageSize));
+                    }
+                    const batchRequests = chunks.map(chunk => {
+                        return BXRestClass.batch({
+                            halt: 1,
+                            cmd: chunk.map(i => {
+                                const param = clone(this.param);
+                                // Устанавливаем start в зависимости от индекса
+                                param.start = (i + 1) * this.pageSize;
+                                // Формируем строку запроса
+                                return this.http.getNameMethod(this.url)
+                                    + '?' + qs.stringify(param, { arrayFormat: 'brackets' });
+                            })
+                        });
+                    });
+                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
+                    toArray(), // Собирает все результаты в массив
+                    map(results => {
+                        if (items.result && items.result.tasks) {
+                            const res = items.result.tasks;
+                            for (let result of results) {
+                                if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
+                                    res.push(...result.result.result.filter(i => i).map(i => i.tasks).flat());
+                                }
+                            }
+                            return (this.map) ?
+                                this.map({ tasks: res })
+                                : res;
+                        }
+                        throw new Error('wrong batch');
+                    }));
+                }
+                return this.mapResForGetAll(items);
+            }
+            return this.mapResForGetAll(items);
+        }), catchError(err => {
+            console.error(err);
+            return throwError(() => err);
+        }));
+    }
+    mapResForGetAll(items) {
+        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navvy-pag-nav-tasks.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/navvy/navvy-pag-nav-tasks.ts"],"names":[],"mappings":"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","sourcesContent":["import { concatMap, from, last, mergeMap, shareReplay, throwError, toArray } from 'rxjs'\r\nimport { catchError, map } from 'rxjs/operators'\r\nimport clone from 'just-clone'\r\nimport { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx'\r\nimport { ReturnTypeNavvy } from './navvy-support'\r\nimport { iBXRestAnswer } from '../../typification/rest/base/answer'\r\nimport { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult'\r\nimport { NavvyPagBase } from './extends/navvy-pag-base'\r\nimport * as qs from 'qs'\r\nimport { BXRest } from '../../rest/base'\r\n\r\nexport class NavvyPagNavTasks<T, R, P extends iBXRestPagination> extends NavvyPagBase<{tasks: T[] | undefined}, R[], P> {\r\n\r\n  save: ReturnTypeNavvy<T, R>[] = []\r\n  resAll() {\r\n    let save: ReturnTypeNavvy<T, R>[] = []\r\n    return this.resultAllEnd()\r\n      .pipe(\r\n        map(v => {\r\n            if (v) {\r\n              save.push(...v as ReturnTypeNavvy<T, R>[])\r\n            }\r\n            return save\r\n          }\r\n        ),\r\n        last(),\r\n        shareReplay(1)\r\n      )\r\n  }\r\n\r\n  private resultAllEnd() {\r\n    let BXRestClass = new BXRest()\r\n    return this.resVanilla().pipe(\r\n      mergeMap(\r\n        items => {\r\n          if (items && instanceOfiBXRestAnswerSuccess(items)) {\r\n            this.save = []\r\n            // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)\r\n            if (items.total && items.total > 50) {\r\n              const count = [...Array(Math.floor(items.total / this.pageSize)).keys()]\r\n\r\n              // Разделяем массив на блоки\r\n              const chunks = []\r\n\r\n              for (let i = 0; i < count.length; i += this.pageSize) {\r\n                chunks.push(count.slice(i, i + this.pageSize))\r\n              }\r\n\r\n              const batchRequests = chunks.map(chunk => {\r\n                return BXRestClass.batch<{tasks: T[] | undefined}[]>({\r\n                  halt: 1,\r\n                  cmd: chunk.map(i => {\r\n                    const param = clone(this.param)\r\n                    // Устанавливаем start в зависимости от индекса\r\n                    param.start = (i + 1) * this.pageSize\r\n\r\n                    // Формируем строку запроса\r\n                    return this.http.getNameMethod(this.url)\r\n                      + '?' + qs.stringify(param, { arrayFormat: 'brackets' })\r\n                  })\r\n                })\r\n              })\r\n\r\n              return from(batchRequests).pipe(\r\n                concatMap(request => request), // Выполняет запросы по очереди\r\n                toArray(), // Собирает все результаты в массив\r\n                map(results => {\r\n                  if(items.result && items.result.tasks) {\r\n                    const res = items.result.tasks as T[]\r\n\r\n                    for (let result of results) {\r\n                      if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {\r\n                        res.push(...result.result.result.filter(i => i).map(i => i.tasks).flat() as T[])\r\n                      }\r\n                    }\r\n\r\n                    return (this.map) ?\r\n                      this.map({tasks: res})\r\n                      : res\r\n                  }\r\n\r\n                  throw new Error('wrong batch')\r\n                })\r\n              )\r\n            }\r\n\r\n            return this.mapResForGetAll(items)\r\n          }\r\n          return this.mapResForGetAll(items)\r\n        }\r\n      ),\r\n      catchError(err => {\r\n        console.error(err)\r\n        return throwError(() => err)\r\n      })\r\n    )\r\n  }\r\n\r\n  private mapResForGetAll(items: iBXRestAnswer<{tasks: T[] | undefined}> | undefined){\r\n    return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(\r\n      map(v => (v && this.map) ? this.map(v) : v)\r\n    ) : from([])\r\n  }\r\n}\r\n"]}

package/esm2022/services/navvy/navvy-pag-nav-with-useless-key.mjs

@@ -0,0 +1,81 @@
+import { catchError, map } from 'rxjs/operators';
+import { concatMap, from, mergeMap, of, throwError, toArray } from 'rxjs';
+import clone from 'just-clone';
+import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+import * as qs from 'qs';
+import { BXRest } from '../../rest/base';
+export class NavvyPagNavWithUselessKey extends NavvyPagBase {
+    constructor() {
+        super(...arguments);
+        this.save = [];
+    }
+    resAll() {
+        let BXRestClass = new BXRest();
+        return this.resVanilla().pipe(mergeMap(items => {
+            if (items && instanceOfiBXRestAnswerSuccess(items)) {
+                if (items.total && items.next) {
+                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
+                    // Разделяем массив на блоки
+                    const chunks = [];
+                    for (let i = 0; i < count.length; i += this.pageSize) {
+                        chunks.push(count.slice(i, i + this.pageSize));
+                    }
+                    const batchRequests = chunks.map(chunk => {
+                        return BXRestClass.batch({
+                            halt: 1,
+                            cmd: chunk.map(i => {
+                                const param = clone(this.param);
+                                // Устанавливаем start в зависимости от индекса
+                                param.start = (i + 1) * this.pageSize;
+                                // Формируем строку запроса
+                                return this.http.getNameMethod(this.url)
+                                    + '?' + qs.stringify(param, { arrayFormat: 'brackets' });
+                            })
+                        }).pipe(map(v => {
+                            if (v && instanceOfiBXRestAnswerSuccess(v) && v.result && v.result.result && items.result) {
+                                return Object.assign({}, items.result, v.result.result);
+                            }
+                            throw new Error('wrong batch');
+                        }));
+                    });
+                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
+                    toArray()); // Собирает все результаты в массив
+                    /*
+                    return this.getAllTaskElapsedItem(func, param).pipe(
+                      map(vEnd => {
+                        if (vEnd && vEnd.result && items.result) {
+                          return merge(clone(vEnd), {result: [...items.result, ...vEnd.result]})
+                        }
+                        return items
+                      })
+                    )
+                     */
+                }
+                else {
+                    return of([items.result]);
+                }
+            }
+            return of(undefined);
+            // return from([BXRestMapResult(items)])
+            // as ReturnType<Observable<T | undefined>, Observable<R | undefined>>
+        }), map(v => {
+            if (v) {
+                const mergedObject = v.reduce((acc, obj) => {
+                    return { ...acc, ...obj };
+                }, {});
+                if (this.map) {
+                    return this.map(mergedObject);
+                }
+                this.save.push(...v);
+                return this.save;
+            }
+            return v;
+        }), catchError(err => {
+            // this.snackBar.error("Проблемы с поточным получение затреканого времени")
+            console.error(err);
+            return throwError(() => err);
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navvy-pag-nav-with-useless-key.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/navvy/navvy-pag-nav-with-useless-key.ts"],"names":[],"mappings":"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","sourcesContent":["import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx'\r\nimport { catchError, map } from 'rxjs/operators'\r\nimport { concatMap, from, mergeMap, of, throwError, toArray } from 'rxjs'\r\nimport clone from 'just-clone'\r\nimport { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult'\r\nimport { NavvyPagBase } from './extends/navvy-pag-base'\r\nimport { ReturnTypeNavvy } from './navvy-support'\r\nimport * as qs from 'qs'\r\nimport { BXRest } from '../../rest/base'\r\n\r\nexport class NavvyPagNavWithUselessKey<T, R, P extends iBXRestPagination> extends NavvyPagBase<Record<string, T>, R[], P> {\r\n\r\n  save: ReturnTypeNavvy<Record<string, T>, R[]> = []\r\n\r\n  resAll() {\r\n    let BXRestClass = new BXRest()\r\n    return this.resVanilla().pipe(\r\n      mergeMap(\r\n        items => {\r\n          if (items && instanceOfiBXRestAnswerSuccess(items)) {\r\n            if (items.total && items.next) {\r\n              const count = [...Array(Math.floor(items.total / this.pageSize)).keys()]\r\n\r\n              // Разделяем массив на блоки\r\n              const chunks = []\r\n\r\n              for (let i = 0; i < count.length; i += this.pageSize) {\r\n                chunks.push(count.slice(i, i + this.pageSize))\r\n              }\r\n\r\n              const batchRequests = chunks.map(chunk => {\r\n                return BXRestClass.batch<Record<string, T>[]>({\r\n                  halt: 1,\r\n                  cmd: chunk.map(i => {\r\n                    const param = clone(this.param)\r\n                    // Устанавливаем start в зависимости от индекса\r\n                    param.start = (i + 1) * this.pageSize\r\n\r\n                    // Формируем строку запроса\r\n                    return this.http.getNameMethod(this.url)\r\n                      + '?' + qs.stringify(param, { arrayFormat: 'brackets' })\r\n                  })\r\n                }).pipe(\r\n                  map(v => {\r\n                    if (v && instanceOfiBXRestAnswerSuccess(v) && v.result && v.result.result && items.result) {\r\n                      return Object.assign({}, items.result, v.result.result) as Record<string, T>\r\n                    }\r\n\r\n                    throw new Error('wrong batch')\r\n                  })\r\n                )\r\n              })\r\n\r\n              return from(batchRequests).pipe(\r\n                concatMap(request => request), // Выполняет запросы по очереди\r\n                toArray()) // Собирает все результаты в массив\r\n              /*\r\n              return this.getAllTaskElapsedItem(func, param).pipe(\r\n                map(vEnd => {\r\n                  if (vEnd && vEnd.result && items.result) {\r\n                    return merge(clone(vEnd), {result: [...items.result, ...vEnd.result]})\r\n                  }\r\n                  return items\r\n                })\r\n              )\r\n               */\r\n            } else {\r\n              return of([items.result as Record<string, T>])\r\n            }\r\n          }\r\n          return of(undefined)\r\n          // return from([BXRestMapResult(items)])\r\n          // as ReturnType<Observable<T | undefined>, Observable<R | undefined>>\r\n        }\r\n      ),\r\n      map(v => {\r\n        if (v) {\r\n          const mergedObject: Record<string, T> = v.reduce((acc, obj) => {\r\n            return { ...acc, ...obj }\r\n          }, {})\r\n\r\n          if(this.map){\r\n            return this.map(mergedObject)\r\n          }\r\n          this.save.push(...v as ReturnTypeNavvy<Record<string, T>, R[]>)\r\n          return this.save\r\n        }\r\n        return v\r\n      }),\r\n      catchError(err => {\r\n        // this.snackBar.error(\"Проблемы с поточным получение затреканого времени\")\r\n        console.error(err)\r\n        return throwError(() => err)\r\n      })\r\n    )\r\n  }\r\n}\r\n"]}

package/esm2022/services/navvy/navvy-pag.mjs

@@ -0,0 +1,67 @@
+import { concatMap, from, mergeMap, toArray } from 'rxjs';
+import { map } from 'rxjs/operators';
+import clone from 'just-clone';
+import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
+import { BXRest } from '../../rest/base';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+import * as qs from 'qs';
+export class NavvyPag extends NavvyPagBase {
+    constructor() {
+        super(...arguments);
+        this.save = [];
+    }
+    resAll() {
+        let BXRestClass = new BXRest();
+        return this.resVanilla().pipe(mergeMap(items => {
+            if (items && instanceOfiBXRestAnswerSuccess(items)) {
+                this.save = [];
+                // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)
+                if (items.total && items.total > 50) {
+                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
+                    // Разделяем массив на блоки
+                    const chunks = [];
+                    for (let i = 0; i < count.length; i += this.pageSize) {
+                        chunks.push(count.slice(i, i + this.pageSize));
+                    }
+                    const batchRequests = chunks.map(chunk => {
+                        return BXRestClass.batch({
+                            halt: 1,
+                            cmd: chunk.map(i => {
+                                const param = clone(this.param);
+                                // Устанавливаем start в зависимости от индекса
+                                param.start = (i + 1) * this.pageSize;
+                                // Формируем строку запроса
+                                return this.http.getNameMethod(this.url)
+                                    + '?' + qs.stringify(param, { arrayFormat: 'brackets' });
+                            })
+                        }).pipe();
+                    });
+                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
+                    toArray(), // Собирает все результаты в массив
+                    map(results => {
+                        const res = items.result;
+                        for (let result of results) {
+                            if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
+                                res.push(...result.result.result.map(i => i).flat());
+                            }
+                        }
+                        return (this.map) ?
+                            this.map(res)
+                            : res;
+                    }));
+                }
+                return this.mapResForGetAll(items);
+            }
+            return this.mapResForGetAll(items);
+        }), map(v => {
+            if (v) {
+                this.save.push(...v);
+            }
+            return this.save;
+        }));
+    }
+    mapResForGetAll(items) {
+        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navvy-pag.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/navvy/navvy-pag.ts"],"names":[],"mappings":"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","sourcesContent":["import { concatMap, from, mergeMap, toArray} from 'rxjs'\r\nimport { map } from 'rxjs/operators'\r\nimport clone from 'just-clone'\r\nimport { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx'\r\nimport { ReturnTypeNavvy } from './navvy-support'\r\nimport { iBXRestAnswer } from '../../typification/rest/base/answer'\r\nimport { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult'\r\nimport { BXRest } from '../../rest/base'\r\nimport { NavvyPagBase } from './extends/navvy-pag-base'\r\nimport * as qs from 'qs'\r\n\r\n\r\nexport class NavvyPag<T, R, P extends iBXRestPagination> extends NavvyPagBase<T[], R[], P> {\r\n\r\n  save: ReturnTypeNavvy<T, R>[] = []\r\n\r\n  resAll() {\r\n    let BXRestClass = new BXRest()\r\n    return this.resVanilla().pipe(\r\n      mergeMap(\r\n        items => {\r\n          if (items && instanceOfiBXRestAnswerSuccess(items)) {\r\n            this.save = []\r\n            // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)\r\n            if (items.total && items.total > 50) {\r\n              const count = [...Array(Math.floor(items.total / this.pageSize)).keys()]\r\n\r\n              // Разделяем массив на блоки\r\n              const chunks = []\r\n\r\n              for (let i = 0; i < count.length; i += this.pageSize) {\r\n                chunks.push(count.slice(i, i + this.pageSize))\r\n              }\r\n\r\n              const batchRequests = chunks.map(chunk => {\r\n                return BXRestClass.batch<T[][]>({\r\n                  halt: 1,\r\n                  cmd: chunk.map(i => {\r\n                    const param = clone(this.param)\r\n                    // Устанавливаем start в зависимости от индекса\r\n                    param.start = (i + 1) * this.pageSize\r\n\r\n                    // Формируем строку запроса\r\n                    return this.http.getNameMethod(this.url)\r\n                      + '?' + qs.stringify(param, { arrayFormat: 'brackets' })\r\n                  })\r\n                }).pipe(\r\n                )\r\n              })\r\n\r\n              return from(batchRequests).pipe(\r\n                concatMap(request => request), // Выполняет запросы по очереди\r\n                toArray(), // Собирает все результаты в массив\r\n                map(results => {\r\n                  const res = items.result as T[]\r\n                  for(let result of results){\r\n                    if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {\r\n                      res.push(...result.result.result.map(i => i).flat())\r\n                    }\r\n                  }\r\n\r\n                  return (this.map) ?\r\n                    this.map(res)\r\n                    : res\r\n                }),\r\n              )\r\n            }\r\n\r\n            return this.mapResForGetAll(items)\r\n          }\r\n          return this.mapResForGetAll(items)\r\n        }\r\n      ),\r\n      map(v => {\r\n        if (v) {\r\n          this.save.push(... v as ReturnTypeNavvy<T, R>[])\r\n        }\r\n\r\n        return this.save\r\n      })\r\n    )\r\n  }\r\n\r\n  private mapResForGetAll(items: iBXRestAnswer<T[]> | undefined) {\r\n    return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(\r\n      map(v => (v && this.map) ? this.map(v) : v)\r\n    ) : from([])\r\n  }\r\n}\r\n"]}

package/esm2022/services/navvy/navvy-simple.mjs

@@ -0,0 +1,4 @@
+import { NavvyPagBase } from './extends/navvy-pag-base';
+export class NavvySimple extends NavvyPagBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2dnktc2ltcGxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYngtcmVzdC9zcmMvc2VydmljZXMvbmF2dnkvbmF2dnktc2ltcGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQUV2RCxNQUFNLE9BQU8sV0FBcUIsU0FBUSxZQUFxQjtDQUU5RCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5hdnZ5UGFnQmFzZSB9IGZyb20gJy4vZXh0ZW5kcy9uYXZ2eS1wYWctYmFzZSdcclxuXHJcbmV4cG9ydCBjbGFzcyBOYXZ2eVNpbXBsZTxULCBSLCBQPiBleHRlbmRzIE5hdnZ5UGFnQmFzZTxULCBSLCBQPiB7XHJcblxyXG59XHJcbiJdfQ==

package/esm2022/services/navvy/navvy-support.mjs

@@ -0,0 +1,15 @@
+import { catchError, map } from 'rxjs/operators';
+import { BXRestMapResult } from '../../functions/mapResult';
+export class NavvySupport {
+    constructor(requestClass) {
+        this.requestClass = requestClass;
+        this.pageSize = 50; // стандартный размер страницы
+    }
+    mapAndError(request) {
+        return request.pipe(map(v => BXRestMapResult(v)), catchError((err) => {
+            console.error(err);
+            throw new Error((err.error) ? err.error : err);
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/navvy.mjs

@@ -1,30 +1,50 @@
-import { NavvySimple } from './Navvy/NavvySimple';
-import { NavvyAlterPagNav } from './Navvy/NavvyAlternativePaginationNavigation';
-import { NavvyPagNav } from './Navvy/NavvyPagNav';
-import { NavvyPagNavWithUselessKey } from './Navvy/NavvyPagNavWithUselessKey';
-import { NavvyPagNavTasks } from './Navvy/NavvyPagNavTasks';
+import { NavvySimple } from './navvy/navvy-simple';
+import { NavvyAlterPagNav } from './navvy/navvy-alternative-pagination-navigation';
+import { NavvyPagNavWithUselessKey } from './navvy/navvy-pag-nav-with-useless-key';
+import { NavvyPagNavTasks } from './navvy/navvy-pag-nav-tasks';
+import { NavvyPag } from './navvy/navvy-pag';
 export class Navvy {
-    constructor(requestClass, mapClass) {
-        this.requestClass = requestClass;
-        this.mapClass = mapClass;
+    simple(url, arg, map) {
+        return new NavvySimple(url, arg !== undefined ? arg : undefined, map);
     }
-    simple(func, map = undefined) {
-        return new NavvySimple(this.requestClass, this.mapClass, func.call(this.requestClass), map);
+    /**
+     * Новый, пока тестируемый метод для api методов с пагинацией
+     *
+     * @param url
+     * @param arg
+     * @param map
+     * @constructor
+     */
+    pagNav(url, arg, map) {
+        return new NavvyPag(url, arg, map);
     }
-    simpleWithArg(func, arg, map = undefined) {
-        return new NavvySimple(this.requestClass, this.mapClass, func.call(this.requestClass, arg), map);
+    // old PagNav
+    // PagNav<T, R, A extends iBXRestPagination>(
+    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    //   arg: A,
+    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
+    //   return new NavvyPagNav(this.requestClass, this.mapClass, func, arg, map)
+    // }
+    // Batch<T, R, A extends iBXRestPagination>(
+    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    //   arg: A,
+    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
+    //   return new NavvyBatch(this.requestClass, this.mapClass, func, arg, map)
+    // }
+    pagNavTasks(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<{tasks: T[] | undefined}> | undefined>,
+    arg, map) {
+        return new NavvyPagNavTasks(url, arg, map);
     }
-    PagNav(func, arg, map = undefined) {
-        return new NavvyPagNav(this.requestClass, this.mapClass, func, arg, map);
+    pagNavWithUselessKey(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<{ [key: string]: T }> | undefined>,
+    arg, map) {
+        return new NavvyPagNavWithUselessKey(url, arg, map);
     }
-    PagNavTasks(func, arg, map = undefined) {
-        return new NavvyPagNavTasks(this.requestClass, this.mapClass, func, arg, map);
-    }
-    PagNavWithUselessKey(func, arg, map = undefined) {
-        return new NavvyPagNavWithUselessKey(this.requestClass, this.mapClass, func, arg, map);
-    }
-    alterPagNav(func, arg, map = undefined) {
-        return new NavvyAlterPagNav(this.requestClass, this.mapClass, func, arg, map);
+    alterPagNav(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    arg, map) {
+        return new NavvyAlterPagNav(url, arg, map);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/vanilla/localStorage.mjs

@@ -1,5 +1,3 @@
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
 export class LocalStorageServices {
     static get(name) {
         return localStorage.getItem(name);
@@ -23,13 +21,5 @@ export class LocalStorageServices {
     static del(name) {
         localStorage.removeItem(name);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LocalStorageServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LocalStorageServices, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LocalStorageServices, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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