bx-rest 0.9.11 → 0.10.0

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 { serializeBitrixParams } from '../../functions/serializeBitrixParams';
+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)
+                                    + '?' + serializeBitrixParams(param);
+                            })
+                        });
+                    });
+                    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 { serializeBitrixParams } from '../../functions/serializeBitrixParams'\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                      + '?' + serializeBitrixParams(param)\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 { serializeBitrixParams } from '../../functions/serializeBitrixParams';
+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)
+                                    + '?' + serializeBitrixParams(param);
+                            })
+                        }).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 { serializeBitrixParams } from '../../functions/serializeBitrixParams'\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                      + '?' + serializeBitrixParams(param)\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,70 @@
+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 { serializeBitrixParams } from '../../functions/serializeBitrixParams';
+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 mathFloor = Math.floor(items.total / this.pageSize);
+                    const count = (mathFloor === items.total / this.pageSize) // если mathFloor равен обычному делению, значит один запрос будет лишним, так как результат первой страницы уже есть, а последняя в данном случаи будет пустая (или с мусорными аднными)
+                        ? [...Array(mathFloor - 1).keys()]
+                        : [...Array(mathFloor).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)
+                                    + '?' + serializeBitrixParams(param);
+                            })
+                        }).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 { serializeBitrixParams } from '../../functions/serializeBitrixParams'\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 mathFloor = Math.floor(items.total / this.pageSize)\r\n              const count = (mathFloor === items.total / this.pageSize) // если mathFloor равен обычному делению, значит один запрос будет лишним, так как результат первой страницы уже есть, а последняя в данном случаи будет пустая (или с мусорными аднными)\r\n                ? [...Array(mathFloor - 1).keys()]\r\n                : [...Array(mathFloor).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                      + '?' + serializeBitrixParams(param)\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

@@ -0,0 +1,61 @@
+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';
+import { NavvyPagNavResultKey } from './navvy/navvy-pag-nav-result-key';
+export * from './navvy/navvy-simple';
+export * from './navvy/navvy-alternative-pagination-navigation';
+export * from './navvy/navvy-pag-nav-with-useless-key';
+export * from './navvy/navvy-pag-nav-tasks';
+export * from './navvy/navvy-pag-nav-result-key';
+export * from './navvy/navvy-pag';
+export * from './navvy/navvy-support';
+export class Navvy {
+    simple(url, arg, map) {
+        return new NavvySimple(url, arg !== undefined ? arg : undefined, map);
+    }
+    /**
+     * Новый, пока тестируемый метод для api методов с пагинацией
+     *
+     * @param url
+     * @param arg
+     * @param map
+     * @constructor
+     */
+    pagNav(url, arg, map) {
+        return new NavvyPag(url, 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);
+    }
+    pagNavResultKey(url, arg, key, map) {
+        return new NavvyPagNavResultKey(url, arg, key, map);
+    }
+    pagNavWithUselessKey(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<{ [key: string]: T }> | undefined>,
+    arg, map) {
+        return new NavvyPagNavWithUselessKey(url, 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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

package/esm2022/services/vanilla/localStorage.mjs

@@ -0,0 +1,25 @@
+export class LocalStorageServices {
+    static get(name) {
+        return localStorage.getItem(name);
+    }
+    static getObj(name) {
+        const localData = localStorage.getItem(name);
+        return (localData) ? JSON.parse(localData) : null;
+    }
+    static set(name, value) {
+        localStorage.setItem(name, value);
+    }
+    static setObj(name, value) {
+        let get = this.get(name);
+        if (get && typeof get === 'object') {
+            localStorage.setItem(name, JSON.stringify(Object.assign(get, value)));
+        }
+        else {
+            localStorage.setItem(name, JSON.stringify(value));
+        }
+    }
+    static del(name) {
+        localStorage.removeItem(name);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/vanilla/sessionStorage.mjs

@@ -0,0 +1,13 @@
+export class SessionStorage {
+    static setItem(name, value) {
+        sessionStorage.setItem(name, JSON.stringify(value));
+    }
+    static getItem(name) {
+        const res = sessionStorage.getItem(name);
+        if (res) {
+            return JSON.parse(res);
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvblN0b3JhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9zZXJ2aWNlcy92YW5pbGxhL3Nlc3Npb25TdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxjQUFjO0lBRXpCLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBWSxFQUFFLEtBQVU7UUFDckMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO0lBQ3JELENBQUM7SUFFRCxNQUFNLENBQUMsT0FBTyxDQUFJLElBQVk7UUFDNUIsTUFBTSxHQUFHLEdBQUcsY0FBYyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN4QyxJQUFHLEdBQUcsRUFBQyxDQUFDO1lBQ04sT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBTSxDQUFBO1FBQzdCLENBQUM7UUFDRCxPQUFPLFNBQVMsQ0FBQTtJQUNsQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgU2Vzc2lvblN0b3JhZ2Uge1xyXG5cclxuICBzdGF0aWMgc2V0SXRlbShuYW1lOiBzdHJpbmcsIHZhbHVlOiBhbnkpe1xyXG4gICAgc2Vzc2lvblN0b3JhZ2Uuc2V0SXRlbShuYW1lLCBKU09OLnN0cmluZ2lmeSh2YWx1ZSkpXHJcbiAgfVxyXG5cclxuICBzdGF0aWMgZ2V0SXRlbTxUPihuYW1lOiBzdHJpbmcpe1xyXG4gICAgY29uc3QgcmVzID0gc2Vzc2lvblN0b3JhZ2UuZ2V0SXRlbShuYW1lKVxyXG4gICAgaWYocmVzKXtcclxuICAgICAgcmV0dXJuIEpTT04ucGFyc2UocmVzKSBhcyBUXHJcbiAgICB9XHJcbiAgICByZXR1cm4gdW5kZWZpbmVkXHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/services/vanilla//321/201ookies.mjs

@@ -0,0 +1,33 @@
+export default class CookiesServices {
+    static get(name) {
+        const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+        if (results)
+            return results[2];
+        else
+            return '';
+    }
+    static set(name, value, age = 0) {
+        let string = name + '=' + value + ';';
+        if (age) {
+            string += ' max-age=' + age;
+        }
+        string += '; SameSite=None; Secure';
+        document.cookie = string;
+    }
+    static setObj(name, value, age = 0) {
+        let string = name + '=' + JSON.stringify(value) + ';';
+        if (age) {
+            string += ' max-age=' + age;
+        }
+        string += '; SameSite=None; Secure';
+        document.cookie = string;
+    }
+    static getObj(name) {
+        const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+        if (results) {
+            return JSON.parse(results[2]);
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/settings.mjs

@@ -0,0 +1,28 @@
+export const DEFAULT_BX_REST_SETTINGS = {
+    auth: {
+        source: 'cookies',
+        key: 'auth'
+    },
+    urls: {
+        source: 'localStorage',
+        key: '',
+        additional_part: 'rest'
+    }
+};
+export const BXRestSettings = {
+    date: {
+        auth: {
+            source: 'cookies',
+            key: 'auth',
+        },
+        urls: {
+            source: 'localStorage',
+            key: '',
+            additional_part: 'rest',
+        },
+    },
+    update(newSettings) {
+        this.date = { ...this.date, ...newSettings };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9zZXR0aW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBb0I7SUFDdkQsSUFBSSxFQUFFO1FBQ0osTUFBTSxFQUFFLFNBQVM7UUFDakIsR0FBRyxFQUFFLE1BQU07S0FDWjtJQUNELElBQUksRUFBRTtRQUNKLE1BQU0sRUFBRSxjQUFjO1FBQ3RCLEdBQUcsRUFBRSxFQUFFO1FBQ1AsZUFBZSxFQUFFLE1BQU07S0FDeEI7Q0FDRixDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHO0lBQzVCLElBQUksRUFBRTtRQUNKLElBQUksRUFBRTtZQUNKLE1BQU0sRUFBRSxTQUFTO1lBQ2pCLEdBQUcsRUFBRSxNQUFNO1NBQ1o7UUFDRCxJQUFJLEVBQUU7WUFDSixNQUFNLEVBQUUsY0FBYztZQUN0QixHQUFHLEVBQUUsRUFBRTtZQUNQLGVBQWUsRUFBRSxNQUFNO1NBQ3hCO0tBQ2lCO0lBRXBCLE1BQU0sQ0FBQyxXQUFxQztRQUMxQyxJQUFJLENBQUMsSUFBSSxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLEdBQUcsV0FBVyxFQUFFLENBQUE7SUFDOUMsQ0FBQztDQUNGLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpQlhSZXN0U2V0dGluZ3MgfSBmcm9tICcuL3R5cGlmaWNhdGlvbi9zZXR0aW5ncydcclxuXHJcbmV4cG9ydCBjb25zdCBERUZBVUxUX0JYX1JFU1RfU0VUVElOR1M6IGlCWFJlc3RTZXR0aW5ncyA9IHtcclxuICBhdXRoOiB7XHJcbiAgICBzb3VyY2U6ICdjb29raWVzJyxcclxuICAgIGtleTogJ2F1dGgnXHJcbiAgfSxcclxuICB1cmxzOiB7XHJcbiAgICBzb3VyY2U6ICdsb2NhbFN0b3JhZ2UnLFxyXG4gICAga2V5OiAnJyxcclxuICAgIGFkZGl0aW9uYWxfcGFydDogJ3Jlc3QnXHJcbiAgfVxyXG59XHJcblxyXG5leHBvcnQgY29uc3QgQlhSZXN0U2V0dGluZ3MgPSB7XHJcbiAgZGF0ZToge1xyXG4gICAgYXV0aDoge1xyXG4gICAgICBzb3VyY2U6ICdjb29raWVzJyxcclxuICAgICAga2V5OiAnYXV0aCcsXHJcbiAgICB9LFxyXG4gICAgdXJsczoge1xyXG4gICAgICBzb3VyY2U6ICdsb2NhbFN0b3JhZ2UnLFxyXG4gICAgICBrZXk6ICcnLFxyXG4gICAgICBhZGRpdGlvbmFsX3BhcnQ6ICdyZXN0JyxcclxuICAgIH0sXHJcbiAgfSBhcyBpQlhSZXN0U2V0dGluZ3MsXHJcblxyXG4gIHVwZGF0ZShuZXdTZXR0aW5nczogUGFydGlhbDxpQlhSZXN0U2V0dGluZ3M+KTogdm9pZCB7XHJcbiAgICB0aGlzLmRhdGUgPSB7IC4uLnRoaXMuZGF0ZSwgLi4ubmV3U2V0dGluZ3MgfVxyXG4gIH0sXHJcbn0iXX0=

package/esm2022/typification/auth/save.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3R5cGlmaWNhdGlvbi9hdXRoL3NhdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgaUJYUmVzdEF1dGgge1xyXG4gIGFjY2Vzc190b2tlbjogc3RyaW5nLCAvLyDQvtGB0L3QvtCy0L3QvtC5INCw0LLRgtC+0YDQuNC30LDRhtC40L7QvdC90YvQuSDRgtC+0LrQtdC9LCDRgtGA0LXQsdGD0LXQvNGL0Lkg0LTQu9GPINC00L7RgdGC0YPQv9CwINC6IFJFU1QgQVBJXHJcbiAgY2xpZW50X2VuZHBvaW50OiBzdHJpbmcsIC8vINCw0LTRgNC10YEgUkVTVC3QuNC90YLQtdGA0YTQtdC50YHQsCDQv9C+0YDRgtCw0LvQsFxyXG4gIGRvbWFpbjogc3RyaW5nLFxyXG4gIGV4cGlyZXM6IG51bWJlcixcclxuICBleHBpcmVzX2luOiBudW1iZXIsXHJcbiAgbWVtYmVyX2lkOiBzdHJpbmcsXHJcbiAgcmVmcmVzaF90b2tlbjogc3RyaW5nLCAvLyDQtNC+0L/QvtC70L3QuNGC0LXQu9GM0L3Ri9C5INCw0LLRgtC+0YDQuNC30LDRhtC40L7QvdC90YvQuSDRgtC+0LrQtdC9LCDRgdC70YPQttCw0YnQuNC5INC00LvRjyDQv9GA0L7QtNC70LXQvdC40Y8g0YHQvtGF0YDQsNC90LXQvdC90L7QuSDQsNCy0YLQvtGA0LjQt9Cw0YbQuNC4XHJcbiAgc2NvcGU6IHN0cmluZyxcclxuICBzZXJ2ZXJfZW5kcG9pbnQ6IHN0cmluZywgLy8g0LDQtNGA0LXRgSBSRVNULdC40L3RgtC10YDRhNC10LnRgdCwINGB0LXRgNCy0LXRgNCwXHJcbiAgc3RhdHVzOiBzdHJpbmcsIC8vINGB0YLQsNGC0YPRgSDQv9GA0LjQu9C+0LbQtdC90LjRjyDQvdCwINC/0L7RgNGC0LDQu9C1XHJcbiAgdXNlcl9pZDogbnVtYmVyLFxyXG4gIHN0YXRlPzogYW55XHJcbn1cclxuIl19

package/esm2022/typification/base/all-key-free.mjs

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