bx-rest 0.9.11 → 0.10.0

package/esm2022/rest/map.mjs

@@ -0,0 +1,39 @@
+import { BXRestMapLists } from '../map/lists';
+import { BXRestMapUser } from '../map/user';
+import { BXRestMapSonetGroup } from '../map/sonet_group';
+import { BXRestMapServer } from '../map/server';
+import { BXRestDisk } from '../request/disk';
+import { BXRestMapCalendar } from '../map/calendar';
+import { BXRestMapLog } from '../map/log';
+import { BXRestMapTask } from '../map/task';
+import { BXRestMapTasks } from '../map/tasks';
+export class BXRestMap {
+    get user() {
+        return BXRestMapUser;
+    }
+    get sonet_group() {
+        return BXRestMapSonetGroup;
+    }
+    get server() {
+        return BXRestMapServer;
+    }
+    get lists() {
+        return BXRestMapLists;
+    }
+    get disk() {
+        return BXRestDisk;
+    }
+    get calendar() {
+        return BXRestMapCalendar;
+    }
+    get log() {
+        return BXRestMapLog;
+    }
+    get task() {
+        return BXRestMapTask;
+    }
+    get tasks() {
+        return BXRestMapTasks;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rest/navvy.mjs

@@ -0,0 +1,58 @@
+import { BXRestMap } from '../map/rest';
+import { Navvy } from '../services/navvy';
+import { BXRestNavvyUser } from '../request-navvy/user';
+import { BXRestNavvyLists } from '../request-navvy/lists';
+import { BXRestNavvyTask } from '../request-navvy/task';
+import { BXRestNavvyTasks } from '../request-navvy/tasks';
+import { BXRestNavvyDisk } from '../request-navvy/disk';
+import { BXRestNavvyBizProc } from '../request-navvy/bizproc';
+import { BXRestNavvyLog } from '../request-navvy/log';
+import { BXRestNavvyCalendar } from '../request-navvy/calendar';
+import { BXRestNavvySonetGroup } from '../request-navvy/sonet_group';
+import { BXRestNavvyServer } from '../request-navvy/server';
+import { BXRestNavvyDepartment } from '../request-navvy/department';
+import { BXRestNavvyIm } from '../request-navvy/im';
+import { BXRestNavvyApp } from '../request-navvy/app';
+import { BXRestNavvyTimeMan } from '../request-navvy/timeman';
+import { BXRestNavvySocialNetWork } from '../request-navvy/socialnetwork';
+import { BXRestNavvyPull } from '../request-navvy/pull';
+import { BXRestNavvyCrm } from '../request-navvy/crm';
+export class BXRestNavvy {
+    constructor() {
+        this.user = new BXRestNavvyUser();
+        this.lists = new BXRestNavvyLists();
+        this.task = new BXRestNavvyTask();
+        this.tasks = new BXRestNavvyTasks();
+        this.disk = new BXRestNavvyDisk();
+        this.bizProc = new BXRestNavvyBizProc();
+        this.log = new BXRestNavvyLog();
+        this.calendar = new BXRestNavvyCalendar();
+        this.sonet_group = new BXRestNavvySonetGroup();
+        this.server = new BXRestNavvyServer();
+        this.department = new BXRestNavvyDepartment();
+        this.im = new BXRestNavvyIm();
+        this.app = new BXRestNavvyApp();
+        this.timeMan = new BXRestNavvyTimeMan();
+        this.socialNetWork = new BXRestNavvySocialNetWork();
+        this.pull = new BXRestNavvyPull();
+        this.crm = new BXRestNavvyCrm();
+        this.Navvy = new Navvy();
+        // public batch<T, C, M>(param: iBXRestNavvyParamBatch<T, C, M>) {
+        //   const modifiedObject = Object.fromEntries(
+        //     Object.entries(param.cmd).map(([key, value]) => {
+        //       let modifiedValue = value.resultVanilla.arguments
+        //       return [key, modifiedValue]
+        //     })
+        //   )
+        //
+        //   return this.BXRest.batch({
+        //     halt: param.halt,
+        //     cmd: modifiedObject
+        //   })
+        // }
+    }
+    profile() {
+        return this.Navvy.simple(['profile'], undefined, BXRestMap.profile);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/base.mjs

@@ -0,0 +1,205 @@
+import { DateTime } from 'luxon';
+/**
+ * Преобразует значение в строку
+ *
+ * @param val
+ * @param throwError
+ */
+export function toStr(val, throwError = false) {
+    if (val === null || val === undefined) {
+        if (throwError) {
+            throw new Error(`Invalid value: ${val} cannot be converted to string`);
+        }
+        return '';
+    }
+    return String(val);
+}
+/**
+ * Преобразует значение в число
+ */
+export function toNum(val, throwError = true, defValue = 0) {
+    const result = Number(val);
+    if (isNaN(result)) {
+        const error = new ToNumError(val);
+        if (throwError)
+            throw error;
+        // Если ошибка не пробрасывается — просто логируем
+        console.error(error.toString());
+        return defValue;
+    }
+    return result;
+}
+/**
+ * Кастомный тип ошибки для числовых преобразований
+ */
+export class ToNumError extends Error {
+    constructor(value) {
+        const valueType = typeof value;
+        const formattedValue = valueType === 'object' ? JSON.stringify(value) : String(value);
+        const message = `Invalid value passed to toNum(): ${formattedValue} (type: ${valueType})`;
+        super(message);
+        this.value = value;
+        this.name = 'ToNumError';
+        // сохраняем стек вызова (отфильтровав сам конструктор)
+        if (this.stack) {
+            const stackLines = this.stack.split('\n');
+            // Удаляем строку конструктора (чтобы стек начинался с места вызова toNum)
+            this.stack = [stackLines[0], ...stackLines.slice(2)].join('\n');
+        }
+    }
+    toString() {
+        return [
+            `❌ [${this.name}] ${this.message}`,
+            this.stack ? `   Stack trace:\n${this.stack}` : '',
+        ].join('\n');
+    }
+}
+/**
+ * Преобразует значение в дату
+ */
+export function toDate(val, format, opt, throwError = true) {
+    if (val instanceof Date) {
+        return val;
+    }
+    else if (typeof val === 'string') {
+        if (format) {
+            if (opt) {
+                return DateTime.fromFormat(val, format, opt).toJSDate();
+            }
+            return DateTime.fromFormat(val, format).toJSDate();
+        }
+        else {
+            return new Date(val);
+        }
+    }
+    else if (typeof val === 'number') {
+        return new Date(val);
+    }
+    if (throwError) {
+        console.error('Wrong date format', val, format);
+        throw new Error('Wrong date format');
+    }
+    return new Date();
+}
+/**
+ * Преобразует дату в строку с учетом временной зоны
+ *
+ * @param date
+ * @param throwError
+ */
+export function toISOStringWithTimezone(date, throwError = true) {
+    if (!(date instanceof Date)) {
+        if (throwError)
+            throw new Error('Invalid value: not a valid Date object');
+        return '';
+    }
+    const tzOffset = -date.getTimezoneOffset();
+    const diff = tzOffset >= 0 ? '+' : '-';
+    const pad = (n) => `${Math.floor(Math.abs(n))}`.padStart(2, '0');
+    return date.getFullYear() +
+        '-' + pad(date.getMonth() + 1) +
+        '-' + pad(date.getDate()) +
+        'T' + pad(date.getHours()) +
+        ':' + pad(date.getMinutes()) +
+        ':' + pad(date.getSeconds()) +
+        diff + pad(tzOffset / 60) +
+        ':' + pad(tzOffset % 60);
+}
+/**
+ * Преобразует значение в булево значение
+ *
+ * @param val
+ * @param throwError
+ */
+export function toBool(val, throwError = true) {
+    switch (typeof val) {
+        case 'string':
+            val = val.toLowerCase();
+            if (val === 'n' || val === 'y') { // битриксовые понятия о bool
+                return val === 'y';
+            }
+            else if (val === 'true' || val === 'false') { // битриксовые понятия о bool
+                return val === 'true';
+            }
+            else {
+                if (throwError)
+                    throw new Error('Invalid value: cannot be converted to boolean');
+                return false;
+            }
+        default:
+            return Boolean(val);
+    }
+}
+/**
+ * Преобразует булево значение в 'Y' или 'N'
+ *
+ * @param val
+ */
+export function toBXYorN(val) {
+    return val ? 'Y' : 'N';
+}
+export function getBaseUrlHttps(url, component = false) {
+    if (component) {
+        return encodeURI(cropUrl(url) + '/');
+    }
+    else {
+        return encodeURI('https://' + cropUrl(url) + '/');
+    }
+}
+/**
+ * Обрезает URL (удаляет протокол)
+ *
+ * @param url
+ */
+export function cropUrl(url) {
+    url = url ? url.replace('https://', '') : '';
+    url = url ? url.replace('http://', '') : '';
+    url = url ? url.replace('https:', '') : '';
+    url = url ? url.replace('http:', '') : '';
+    return url;
+}
+/**
+ * Преобразует файл в base64
+ *
+ * @param file
+ */
+export function getBase64File(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = error => reject(error);
+    });
+}
+/**
+ * Получить файл в формате base64 с разбивкой на заголовок и данные
+ *
+ * @param file
+ */
+export async function getBase64FileLikeStr(file) {
+    const result = await getBase64File(file);
+    if (typeof result === 'string') {
+        const split = result.split(',');
+        return {
+            header: split[0],
+            val: split[1]
+        };
+    }
+    return undefined;
+}
+export function prepareBaseAddress(url, add = '') {
+    // if (url.search('https://') !== 0 && url.search('http://')) {
+    //   url = 'https://' + url
+    // }
+    if (add && add.length > 0) {
+        if (url.lastIndexOf('/') !== (url.length - 1)) {
+            url = url + '/';
+        }
+        url = url + add;
+    }
+    if (url.lastIndexOf('/') !== (url.length - 1)) {
+        url = url + '/';
+    }
+    return url;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../projects/bx-rest/src/services/base.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateTime, DateTimeOptions } from 'luxon'\r\n\r\n/**\r\n * Преобразует значение в строку\r\n *\r\n * @param val\r\n * @param throwError\r\n */\r\nexport function toStr(val: any, throwError = false): string {\r\n  if (val === null || val === undefined) {\r\n    if (throwError) {\r\n      throw new Error(`Invalid value: ${val} cannot be converted to string`)\r\n    }\r\n    return ''\r\n  }\r\n  return String(val)\r\n}\r\n\r\n/**\r\n * Преобразует значение в число\r\n */\r\nexport function toNum(val: any, throwError = true, defValue = 0): number {\r\n  const result = Number(val)\r\n\r\n  if (isNaN(result)) {\r\n    const error = new ToNumError(val)\r\n\r\n    if (throwError) throw error\r\n\r\n    // Если ошибка не пробрасывается — просто логируем\r\n    console.error(error.toString())\r\n    return defValue\r\n  }\r\n\r\n  return result\r\n}\r\n\r\n/**\r\n * Кастомный тип ошибки для числовых преобразований\r\n */\r\nexport class ToNumError extends Error {\r\n  constructor(public readonly value: any) {\r\n    const valueType = typeof value\r\n    const formattedValue =\r\n      valueType === 'object' ? JSON.stringify(value) : String(value)\r\n    const message = `Invalid value passed to toNum(): ${formattedValue} (type: ${valueType})`\r\n    super(message)\r\n    this.name = 'ToNumError'\r\n\r\n    // сохраняем стек вызова (отфильтровав сам конструктор)\r\n    if (this.stack) {\r\n      const stackLines = this.stack.split('\\n')\r\n      // Удаляем строку конструктора (чтобы стек начинался с места вызова toNum)\r\n      this.stack = [stackLines[0], ...stackLines.slice(2)].join('\\n')\r\n    }\r\n  }\r\n\r\n  override toString(): string {\r\n    return [\r\n      `❌ [${this.name}] ${this.message}`,\r\n      this.stack ? `   Stack trace:\\n${this.stack}` : '',\r\n    ].join('\\n')\r\n  }\r\n}\r\n\r\n/**\r\n * Преобразует значение в дату\r\n */\r\nexport function toDate(val: number | string | Date, format?: string, opt?: DateTimeOptions, throwError = true): Date {\r\n  if (val instanceof Date) {\r\n    return val\r\n  } else if (typeof val === 'string') {\r\n    if (format) {\r\n      if (opt) {\r\n        return DateTime.fromFormat(val, format, opt).toJSDate()\r\n      }\r\n      return DateTime.fromFormat(val, format).toJSDate()\r\n    } else {\r\n      return new Date(val)\r\n    }\r\n  } else if (typeof val === 'number') {\r\n    return new Date(val)\r\n  }\r\n\r\n  if (throwError) {\r\n    console.error('Wrong date format', val, format)\r\n    throw new Error('Wrong date format')\r\n  }\r\n\r\n  return new Date()\r\n}\r\n\r\n/**\r\n * Преобразует дату в строку с учетом временной зоны\r\n *\r\n * @param date\r\n * @param throwError\r\n */\r\nexport function toISOStringWithTimezone(date: Date, throwError = true): string {\r\n  if (!(date instanceof Date)) {\r\n    if (throwError) throw new Error('Invalid value: not a valid Date object')\r\n    return ''\r\n  }\r\n\r\n  const tzOffset = -date.getTimezoneOffset()\r\n  const diff = tzOffset >= 0 ? '+' : '-'\r\n  const pad = (n: number) => `${Math.floor(Math.abs(n))}`.padStart(2, '0')\r\n  return date.getFullYear() +\r\n    '-' + pad(date.getMonth() + 1) +\r\n    '-' + pad(date.getDate()) +\r\n    'T' + pad(date.getHours()) +\r\n    ':' + pad(date.getMinutes()) +\r\n    ':' + pad(date.getSeconds()) +\r\n    diff + pad(tzOffset / 60) +\r\n    ':' + pad(tzOffset % 60)\r\n}\r\n\r\n/**\r\n * Преобразует значение в булево значение\r\n *\r\n * @param val\r\n * @param throwError\r\n */\r\nexport function toBool(val: any, throwError = true): boolean {\r\n  switch (typeof val) {\r\n    case 'string':\r\n      val = val.toLowerCase()\r\n      if (val === 'n' || val === 'y') { // битриксовые понятия о bool\r\n        return val === 'y'\r\n      } else if (val === 'true' || val === 'false') { // битриксовые понятия о bool\r\n        return val === 'true'\r\n      } else {\r\n        if (throwError) throw new Error('Invalid value: cannot be converted to boolean')\r\n        return false\r\n      }\r\n    default:\r\n      return Boolean(val)\r\n  }\r\n}\r\n\r\n/**\r\n * Преобразует булево значение в 'Y' или 'N'\r\n *\r\n * @param val\r\n */\r\nexport function toBXYorN(val: boolean): string {\r\n  return val ? 'Y' : 'N'\r\n}\r\n\r\nexport function getBaseUrlHttps(url: string, component = false): string {\r\n  if (component) {\r\n    return encodeURI(cropUrl(url) + '/')\r\n  } else {\r\n    return encodeURI('https://' + cropUrl(url) + '/')\r\n  }\r\n}\r\n\r\n/**\r\n * Обрезает URL (удаляет протокол)\r\n *\r\n * @param url\r\n */\r\nexport function cropUrl(url: string): string {\r\n  url = url ? url.replace('https://', '') : ''\r\n  url = url ? url.replace('http://', '') : ''\r\n  url = url ? url.replace('https:', '') : ''\r\n  url = url ? url.replace('http:', '') : ''\r\n  return url\r\n}\r\n\r\n/**\r\n * Преобразует файл в base64\r\n *\r\n * @param file\r\n */\r\nexport function getBase64File(file: File): Promise<string> {\r\n  return new Promise((resolve, reject) => {\r\n    const reader = new FileReader()\r\n    reader.readAsDataURL(file)\r\n    reader.onload = () => resolve(reader.result as string)\r\n    reader.onerror = error => reject(error)\r\n  })\r\n}\r\n\r\n/**\r\n * Получить файл в формате base64 с разбивкой на заголовок и данные\r\n *\r\n * @param file\r\n */\r\nexport async function getBase64FileLikeStr(file: File): Promise<{\r\n  header: string,\r\n  val: string\r\n} | undefined> {\r\n  const result = await getBase64File(file)\r\n  if (typeof result === 'string') {\r\n    const split = result.split(',')\r\n    return {\r\n      header: split[0],\r\n      val: split[1]\r\n    }\r\n  }\r\n  return undefined\r\n}\r\n\r\nexport function prepareBaseAddress(url: string, add: string | undefined = '') {\r\n  // if (url.search('https://') !== 0 && url.search('http://')) {\r\n  //   url = 'https://' + url\r\n  // }\r\n\r\n  if (add && add.length > 0) {\r\n    if (url.lastIndexOf('/') !== (url.length - 1)) {\r\n      url = url + '/'\r\n    }\r\n\r\n    url = url + add\r\n  }\r\n\r\n  if (url.lastIndexOf('/') !== (url.length - 1)) {\r\n    url = url + '/'\r\n  }\r\n\r\n  return url\r\n}"]}

package/esm2022/services/http/HttpBX.mjs

@@ -0,0 +1,142 @@
+import { throwError, forkJoin, from } from 'rxjs';
+import clone from 'just-clone';
+import { HttpServices } from './http';
+import flatten from 'just-flatten-it';
+import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
+import { switchMap } from 'rxjs/operators';
+import { prepareBaseAddress } from '../base';
+import { serializeBitrixParams as stringifyBitrixParams } from '../../functions/serializeBitrixParams';
+export class HttpBXServices extends HttpServices {
+    /**
+     * Это пиздец а не метод
+     * TODO: Удалить данный метод после реализации его в разделе Navvy
+     * @param param
+     */
+    branch(param) {
+        let prepareParam = Object.entries(this.prepareBatch(param));
+        const size = 50; // больше не отдаст
+        let subarray = []; //массив в который будет выведен результат.
+        for (let i = 0; i < Math.ceil(prepareParam.length / size); i++) {
+            subarray[i] = prepareParam.slice((i * size), (i * size) + size);
+        }
+        return forkJoin(subarray.map(i => {
+            return this.httpPost('batch.json', {
+                halt: 0,
+                cmd: Object.assign({}, ...i.map(x => {
+                    return { [x[0]]: x[1] };
+                }))
+            });
+        }));
+    }
+    prepareBatch(param) {
+        let res = Object.keys(param).reduce((obj, key) => {
+            obj[key] = '';
+            return obj;
+        }, {});
+        for (let key in param) {
+            if (typeof key === 'string' || typeof key === 'number' && param[key].param) {
+                res[key] = param[key].name + '?' + stringifyBitrixParams(param[key].param);
+            }
+        }
+        return res;
+    }
+    mapBranchResult(res) {
+        return Object.assign([], ...res.map(i => (instanceOfiBXRestAnswerSuccess(i) && instanceOfiBXRestAnswerSuccess(i.result)) ? i.result.result : undefined));
+    }
+    mapBranchResultWithoutKey(res) {
+        return flatten(Object.assign([], ...res.map(i => (instanceOfiBXRestAnswerSuccess(i) && instanceOfiBXRestAnswerSuccess(i.result))
+            ? i.result.result
+            : undefined)));
+    }
+    /**
+     * Основной метод для запросов
+     *
+     * @param name
+     * @param params
+     */
+    post(name, params = {}) {
+        return this.httpPost(this.getNameMethod(name), params);
+    }
+    /**
+     * Второстепенный метод для запросов. По возможности лучше не использовать
+     *
+     * @param name
+     * @param params
+     */
+    get(name, params = {}) {
+        return this.httpGet(this.getNameMethod(name), params);
+    }
+    httpPost(url, params = {}) {
+        const paramsClone = clone(params);
+        const key = this.session.getKeyAuth();
+        const auth = this.session.getAuthParams();
+        const checkIsOn = this.session.getCheckAuthParamsIsOn();
+        if (checkIsOn) {
+            if (!auth) {
+                return throwError(() => this.session.getAuthError('post'));
+            }
+            if (key !== 'OAuth2') {
+                paramsClone[key] = auth;
+            }
+        }
+        return this.session.getBaseUrl().pipe(switchMap((baseUrl) => {
+            if (!baseUrl) {
+                return throwError(() => this.session.getBaseUrlError('post'));
+            }
+            const fullUrl = prepareBaseAddress(baseUrl) + url;
+            if (key === 'sessid') {
+                // Преобразуем параметры в формат x-www-form-urlencoded
+                const bodyString = this.serializeBitrixParams(paramsClone);
+                return from(this.axiosInstance.post(fullUrl, bodyString, {
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                }).then((response) => response.data));
+            }
+            return from(this.axiosInstance.post(fullUrl, paramsClone, {
+                withCredentials: key === 'OAuth2',
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            }).then((response) => response.data));
+        }));
+    }
+    serializeBitrixParams(params) {
+        return stringifyBitrixParams(params);
+    }
+    // Мб не работает
+    httpGet(url, params = {}) {
+        if (params === null) {
+            params = {};
+        }
+        const auth = this.session.getAuthParams();
+        const paramsClone = clone(params);
+        const checkIsOn = this.session.getCheckAuthParamsIsOn();
+        const key = this.session.getKeyAuth();
+        if (checkIsOn) {
+            if (!auth) {
+                return throwError(() => this.session.getAuthError('get'));
+            }
+            if (key !== 'OAuth2') {
+                paramsClone[key] = auth;
+            }
+        }
+        let options = {
+            params: paramsClone
+            // params: JSON.stringify(paramsClone)
+        };
+        return this.session.getBaseUrl().pipe(switchMap((baseUrl) => {
+            if (!baseUrl) {
+                return throwError(() => this.session.getBaseUrlError('get'));
+            }
+            return from(this.axiosInstance.post(prepareBaseAddress(baseUrl) + url, options, {
+                withCredentials: key === 'OAuth2',
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            }).then((response) => response.data));
+        }));
+    }
+    getNameMethod(arr) {
+        return arr.join('.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HttpBX.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/http/HttpBX.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, throwError, forkJoin, from } from 'rxjs'\r\nimport clone from 'just-clone'\r\nimport { HttpServices } from './http'\r\nimport {\r\n  iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp, keyBatch,\r\n} from '../../typification/rest/batch/batchRequestParam'\r\nimport { iBXRestAnswer } from '../../typification/rest/base/answer'\r\nimport flatten from 'just-flatten-it'\r\nimport { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult'\r\nimport { switchMap } from 'rxjs/operators'\nimport { prepareBaseAddress } from '../base'\nimport { serializeBitrixParams as stringifyBitrixParams } from '../../functions/serializeBitrixParams'\n\r\nexport class HttpBXServices extends HttpServices {\r\n\r\n  /**\r\n   * Это пиздец а не метод\r\n   * TODO: Удалить данный метод после реализации его в разделе Navvy\r\n   * @param param\r\n   */\r\n  branch<T, A>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[])\r\n    : Observable<iBatchRequestAnswer<A>[] | undefined> {\r\n    let prepareParam = Object.entries<string>(this.prepareBatch<T>(param))\r\n    const size = 50 // больше не отдаст\r\n    let subarray = [] //массив в который будет выведен результат.\r\n    for (let i = 0; i < Math.ceil(prepareParam.length / size); i++) {\r\n      subarray[i] = prepareParam.slice((i * size), (i * size) + size)\r\n    }\r\n\r\n    return forkJoin(\r\n      subarray.map(i => {\r\n        return this.httpPost('batch.json', {\r\n          halt: 0,\r\n          cmd: Object.assign({}, ...i.map(x => {\r\n            return {[x[0]]: x[1]}\r\n          }))\r\n        })\r\n      })\r\n    ) as Observable<iBatchRequestAnswer<A>[]>\r\n  }\r\n\r\n  prepareBatch<T>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): iBatchRequestParamHttp {\r\n    let res: iBatchRequestParamHttp = Object.keys(param).reduce(\r\n      (obj, key) => {\r\n        obj[key] = ''\r\n        return obj\r\n      },\r\n      {} as iBatchRequestParamHttp\r\n    )\r\n    for (let key in param) {\r\n      if (typeof key === 'string' || typeof key === 'number' && param[key].param) {\r\n        res[key] = param[key].name + '?' + stringifyBitrixParams(param[key].param)\n      }\r\n    }\r\n    return res\r\n  }\r\n\r\n  mapBranchResult<T>(res: iBatchRequestAnswer<T>[]) {\r\n    return Object.assign([], ...res.map(i =>\r\n      (instanceOfiBXRestAnswerSuccess(i) && instanceOfiBXRestAnswerSuccess(i.result)) ? i.result.result : undefined)\r\n    ) as Record<keyBatch, T>\r\n  }\r\n\r\n  mapBranchResultWithoutKey<T>(res: iBatchRequestAnswer<T>[]): T[] {\r\n    return flatten<T>(Object.assign([], ...res.map(i =>\r\n      (instanceOfiBXRestAnswerSuccess(i) && instanceOfiBXRestAnswerSuccess(i.result))\r\n        ? i.result.result\r\n        : undefined))\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Основной метод для запросов\r\n   *\r\n   * @param name\r\n   * @param params\r\n   */\r\n  post<T>(name: string[], params: any = {}) {\r\n    return this.httpPost<iBXRestAnswer<T>>(this.getNameMethod(name), params)\r\n  }\r\n\r\n  /**\r\n   * Второстепенный метод для запросов. По возможности лучше не использовать\r\n   *\r\n   * @param name\r\n   * @param params\r\n   */\r\n  get<T>(name: string[], params: any = {}) {\r\n    return this.httpGet<iBXRestAnswer<T>>(this.getNameMethod(name), params)\r\n  }\r\n\r\n  override httpPost<T>(url: string, params: any = {}): Observable<T | undefined> {\n    const paramsClone = clone(params)\n    const key = this.session.getKeyAuth()\n    const auth = this.session.getAuthParams()\n    const checkIsOn = this.session.getCheckAuthParamsIsOn()\n\n    if (checkIsOn) {\n      if (!auth) {\n        return throwError(() => this.session.getAuthError('post'))\n      }\n\n      if (key !== 'OAuth2') {\n        paramsClone[key] = auth\n      }\n    }\n\n    return this.session.getBaseUrl().pipe(\n      switchMap((baseUrl) => {\n        if (!baseUrl) {\n          return throwError(() => this.session.getBaseUrlError('post'))\n        }\n\r\n        const fullUrl = prepareBaseAddress(baseUrl) + url\r\n\r\n        if (key === 'sessid') {\r\n          // Преобразуем параметры в формат x-www-form-urlencoded\r\n          const bodyString = this.serializeBitrixParams(paramsClone)\n          return from(\r\n            this.axiosInstance.post<T>(fullUrl, bodyString, {\r\n              headers: {'Content-Type': 'application/x-www-form-urlencoded'},\r\n            }).then((response) => response.data)\r\n          )\r\n        }\r\n\r\n        return from(\r\n          this.axiosInstance.post<T>(fullUrl, paramsClone,\r\n            {\r\n              withCredentials: key === 'OAuth2',\r\n              headers: {\r\n                'Content-Type': 'application/json',\r\n              }\r\n            }\r\n          ).then((response) => response.data)\r\n        )\r\n      })\r\n    )\r\n  }\n\n  serializeBitrixParams(params: unknown): string {\n    return stringifyBitrixParams(params)\n  }\n\n  // Мб не работает\n  override httpGet<T>(url: string, params: any = {}): Observable<T | undefined> {\n    if (params === null) {\n      params = {}\n    }\n    const auth = this.session.getAuthParams()\n    const paramsClone = clone(params)\n    const checkIsOn = this.session.getCheckAuthParamsIsOn()\n    const key = this.session.getKeyAuth()\n\n    if (checkIsOn) {\n      if (!auth) {\n        return throwError(() => this.session.getAuthError('get'))\n      }\n\n      if (key !== 'OAuth2') {\n        paramsClone[key] = auth\n      }\n    }\n\n    let options = {\n      params: paramsClone\n      // params: JSON.stringify(paramsClone)\r\n    }\r\n\r\n    return this.session.getBaseUrl().pipe(\n      switchMap((baseUrl) => {\n        if (!baseUrl) {\n          return throwError(() => this.session.getBaseUrlError('get'))\n        }\n\n        return from(\n          this.axiosInstance.post<T>(prepareBaseAddress(baseUrl) + url, options,\n            {\n              withCredentials: key === 'OAuth2',\n              headers: {\n                'Content-Type': 'application/json',\n              }\n            }\r\n          ).then((response) => response.data)\r\n        )\r\n      })\r\n    )\r\n  }\r\n\r\n  getNameMethod(arr: string[]) {\r\n    return arr.join('.')\r\n  }\r\n\r\n}\r\n\r\n"]}

package/esm2022/services/http/HttpData.mjs

@@ -0,0 +1,77 @@
+export class HttpData {
+    constructor() {
+        this.defSettings = {
+            timeZone: {
+                calc: true,
+                levelOut: false
+            }
+        };
+    }
+    getHttpParamsPost(obj, sendHttpParams = new FormData(), nesting = [], settings = this.defSettings) {
+        if (obj instanceof Blob) {
+            let first = nesting[0];
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first;
+            sendHttpParams.set(setKey, obj);
+            return sendHttpParams;
+        }
+        else if (obj instanceof Date) {
+            let first = nesting[0];
+            let tzoffset = (settings.timeZone.calc) ? obj.getTimezoneOffset() * 60000 : 0; // вычисляем влияние часового пояса
+            let levelOut = (settings.timeZone.levelOut) ? obj.getTimezoneOffset() * 60000 : 0; // вычисляем влияние часового пояса
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first;
+            sendHttpParams.set(setKey, (new Date(obj.valueOf() + tzoffset - levelOut)).toISOString());
+            return sendHttpParams;
+        }
+        else {
+            for (const key in obj) {
+                let setKey = '';
+                if (nesting.length) {
+                    let first = nesting[0];
+                    setKey = (nesting.length > 1)
+                        ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                        : first + '[' + key + ']';
+                }
+                else {
+                    setKey = key;
+                }
+                switch (typeof obj[key]) {
+                    case 'string':
+                        sendHttpParams.set(setKey, obj[key]);
+                        break;
+                    case 'symbol':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
+                        sendHttpParams.set(setKey, String(obj[key]));
+                        break;
+                    case 'object':
+                        nesting.push(key);
+                        sendHttpParams = this.getHttpParamsPost(obj[key], sendHttpParams, nesting, settings);
+                        nesting.pop();
+                        break;
+                    case 'function':
+                    case 'undefined':
+                    default:
+                        console.error('You sent something wrong', obj[key], typeof obj[key], typeof obj);
+                }
+            }
+        }
+        return sendHttpParams;
+    }
+    sliceArrayIntoChunks(arr, chunkSize) {
+        const res = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize);
+            res.push(chunk);
+        }
+        return res;
+    }
+    removingMultipleSlashes(str) {
+        return str.replace(/\/{2,}/g, '/');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/http/base/base.mjs

@@ -0,0 +1,4 @@
+import { HttpData } from '../HttpData';
+export class BaseHttp extends HttpData {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3NlcnZpY2VzL2h0dHAvYmFzZS9iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxhQUFhLENBQUE7QUFFdEMsTUFBTSxPQUFnQixRQUFTLFNBQVEsUUFBUTtDQVk5QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGlIdHRwUGFyYW1TZXR0aW5ncyB9IGZyb20gJy4uLy4uLy4uL3R5cGlmaWNhdGlvbi9yZXN0L3NldHRpbmdzJ1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcydcclxuaW1wb3J0IHsgSHR0cERhdGEgfSBmcm9tICcuLi9IdHRwRGF0YSdcclxuXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBCYXNlSHR0cCBleHRlbmRzIEh0dHBEYXRhIHtcclxuXHJcbiAgICBhYnN0cmFjdCBodHRwR2V0PFQ+KFxyXG4gICAgICAgIHVybDogc3RyaW5nLFxyXG4gICAgICAgIHBhcmFtczogYW55LFxyXG4gICAgICAgIHNldHRpbmdzOiBpSHR0cFBhcmFtU2V0dGluZ3NcclxuICAgICk6IE9ic2VydmFibGU8VCB8IHVuZGVmaW5lZD5cclxuXHJcbiAgICBhYnN0cmFjdCBodHRwUG9zdDxUPih1cmw6IHN0cmluZyxcclxuICAgICAgICAgICAgICAgICAgICAgICBwYXJhbXM6IGFueSAsXHJcbiAgICAgICAgICAgICAgICAgICAgICAgc2V0dGluZ3M6IGlIdHRwUGFyYW1TZXR0aW5nc1xyXG4gICAgKTogT2JzZXJ2YWJsZTxUIHwgdW5kZWZpbmVkPlxyXG59XHJcbiJdfQ==