bx-rest 1.2.0 → 1.4.0

package/esm2022/services/frame/transport.mjs

@@ -0,0 +1,224 @@
+/**
+ * Обмен сообщениями между iframe приложения и порталом Bitrix24 — тот
+ * транспорт, на котором построены команды BX24.js: страница приложения шлёт
+ * команду родительскому окну портала через postMessage, портал отвечает
+ * сообщением с тем же callbackId.
+ *
+ * ВНИМАНИЕ: протокол внутренний и недокументированный — Bitrix24 может
+ * изменить его без предупреждения. Транспорт повторяет BX24.js
+ * (https://api.bitrix24.com/api/v1/, скачан 2026-10-29, Last-Modified
+ * 2022-03-17, sha256 945ad491df8ffb7490b89f4914a439b5a3f575c950c3480562815716a3e07f23)
+ * и сверен с ответной стороной портала — `/bitrix/js/rest/applayout.js`
+ * (Last-Modified 2024-05-15, sha256 3efd6ab57a4778493a26d10ae0987a82e19fc012ed9935f5c6afa78c4052fcb5).
+ * Всё знание о протоколе — только в этом модуле (`services/frame`).
+ */
+/**
+ * Ошибка обращения к порталу из iframe. `code`:
+ * - `NOT_IN_FRAME` — страница открыта не в iframe приложения Bitrix24;
+ * - `TIMEOUT` — портал не ответил за отведённое время;
+ * - `NO_AUTH` — портал ответил без токена;
+ * - `BAD_RESPONSE` — ответ портала не удалось разобрать;
+ * - `CANCELLED` — ожидание отменено через `signal` или новым вызовом того же диалога;
+ * - `ACCESS_DENIED` — команда доступна только администратору портала.
+ */
+export class BXRestFrameError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'BXRestFrameError';
+    }
+}
+/**
+ * Параметры портала (DOMAIN, PROTOCOL, APP_SID) читаются в конструкторе —
+ * так же, как это делает BX24.js, из `window.name`: портал задаёт имя
+ * iframe приложения в виде `DOMAIN|PROTOCOL|APP_SID`. Если там их нет —
+ * из query страницы (`?DOMAIN=…&PROTOCOL=…&APP_SID=…`), с которым портал
+ * открывает обработчик приложения. Конструктор не бросает исключений:
+ * вне iframe ошибку вернут сами команды.
+ */
+export class FrameTransport {
+    constructor() {
+        this.frame = readPortalFrame();
+    }
+    /** Домен портала из параметров фрейма — как `BX24.getDomain()`. */
+    get domain() {
+        return this.frame?.domain ?? '';
+    }
+    /**
+     * Команда, на которую портал не отвечает (`reloadWindow`, `imCallTo`, ...).
+     * Вне iframe бросает `BXRestFrameError` с кодом `NOT_IN_FRAME`.
+     */
+    post(command, params) {
+        this.send(this.requireFrame(), command, params, '');
+    }
+    /** Команда с одним ответом портала. */
+    request(command, params, options) {
+        return new Promise((resolve, reject) => {
+            let frame;
+            try {
+                frame = this.requireFrame();
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            const { timeout, onTimeout = 'reject', signal } = options;
+            if (signal?.aborted) {
+                reject(cancelled(command));
+                return;
+            }
+            const callbackId = uniqId();
+            let timer;
+            const finish = () => {
+                clearTimeout(timer);
+                stopListening();
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const onAbort = () => {
+                finish();
+                reject(cancelled(command));
+            };
+            const stopListening = this.listen(frame, callbackId, payload => {
+                finish();
+                const answer = parsePayload(payload);
+                if (answer.ok) {
+                    resolve(answer.value);
+                }
+                else {
+                    // В тексте ошибки — только команда, без тела ответа: в нём бывают токены
+                    reject(new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} with a payload that is not JSON.`));
+                }
+            });
+            if (timeout !== false) {
+                timer = setTimeout(() => {
+                    finish();
+                    if (onTimeout === 'resolve') {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(new BXRestFrameError('TIMEOUT', [
+                            `Bitrix24 did not answer ${command} within ${timeout} ms:`,
+                            'the page is not opened inside a Bitrix24 portal iframe, or the portal could not process the command.'
+                        ].join(' ')));
+                    }
+                }, timeout);
+            }
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.send(frame, command, params, callbackId);
+        });
+    }
+    /**
+     * Команда, на которую портал отвечает многократно (`placementBindEvent`):
+     * `handler` вызывается на каждый ответ. Возвращает функцию отписки —
+     * она только перестаёт слушать: отменить подписку на стороне портала
+     * протокол не позволяет. Вне iframe бросает `BXRestFrameError`.
+     */
+    subscribe(command, params, handler) {
+        const frame = this.requireFrame();
+        const callbackId = uniqId();
+        const stopListening = this.listen(frame, callbackId, payload => {
+            const answer = parsePayload(payload);
+            if (answer.ok) {
+                handler(answer.value);
+            }
+        });
+        this.send(frame, command, params, callbackId);
+        return stopListening;
+    }
+    requireFrame() {
+        if (!this.frame) {
+            throw new BXRestFrameError('NOT_IN_FRAME', 'Bitrix24 frame parameters (DOMAIN, APP_SID) were not found in window.name or in the URL query: '
+                + 'the page is not opened as a Bitrix24 application.');
+        }
+        if (window.parent === window) {
+            throw new BXRestFrameError('NOT_IN_FRAME', 'The page is not opened inside an iframe, so there is no Bitrix24 portal to send commands to.');
+        }
+        return this.frame;
+    }
+    /**
+     * Формат — как у BX24.js. Обычно строка `команда:параметры:callbackId:APP_SID`
+     * (портал разбирает её с конца, поэтому параметры и callbackId могут быть
+     * пустыми); для команд с `:` в имени — объект.
+     */
+    send(frame, command, params, callbackId) {
+        const message = command.includes(':')
+            ? { method: command, params: params ? params : '', callback: callbackId, appSid: frame.appSid }
+            : `${command}:${params ? JSON.stringify(params) : ''}:${callbackId}:${frame.appSid}`;
+        window.parent.postMessage(message, frame.origin);
+    }
+    /** Ответ портала — строка `callbackId:JSON` (или `callbackId:`, если ответ пустой). */
+    listen(frame, callbackId, onAnswer) {
+        const portalWindow = window.parent;
+        const onMessage = (event) => {
+            // Ответ принимаем только от родительского окна и только с origin
+            // портала — BX24.js проверяет лишь origin
+            if (event.source !== portalWindow || event.origin !== frame.origin || typeof event.data !== 'string') {
+                return;
+            }
+            const separator = event.data.indexOf(':');
+            const id = separator < 0 ? event.data : event.data.slice(0, separator);
+            if (id === callbackId) {
+                onAnswer(separator < 0 ? '' : event.data.slice(separator + 1));
+            }
+        };
+        window.addEventListener('message', onMessage);
+        return () => window.removeEventListener('message', onMessage);
+    }
+}
+function parsePayload(payload) {
+    if (payload === '') {
+        return { ok: true, value: undefined };
+    }
+    try {
+        return { ok: true, value: JSON.parse(payload) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function cancelled(command) {
+    return new BXRestFrameError('CANCELLED', `Waiting for the Bitrix24 answer to ${command} was cancelled.`);
+}
+function readPortalFrame() {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    // BX24.js: window.name = 'DOMAIN|PROTOCOL|APP_SID'
+    const [nameDomain, nameProtocol, nameAppSid] = (typeof window.name === 'string' ? window.name : '').split('|');
+    const fromName = toPortalFrame(nameDomain, nameProtocol, nameAppSid);
+    if (fromName) {
+        return fromName;
+    }
+    try {
+        const query = new URLSearchParams(window.location?.search ?? '');
+        return toPortalFrame(query.get('DOMAIN'), query.get('PROTOCOL'), query.get('APP_SID'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function toPortalFrame(rawDomain, rawProtocol, appSid) {
+    // Как BX24.js: порт по умолчанию отрезается, PROTOCOL 1 — https
+    const domain = (rawDomain ?? '').replace(/:(80|443)$/, '');
+    if (!domain || !appSid) {
+        return undefined;
+    }
+    const protocol = (Number.parseInt(rawProtocol ?? '', 10) || 0) ? 'https' : 'http';
+    try {
+        const url = new URL(`${protocol}://${domain}`);
+        // В DOMAIN должен быть только хост (и порт) — никаких путей и логинов
+        if (url.host !== domain.toLowerCase() || url.username || url.password) {
+            return undefined;
+        }
+        return { domain, origin: url.origin, appSid };
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniqId() {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/frame/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Обмен сообщениями между iframe приложения и порталом Bitrix24 — тот\n * транспорт, на котором построены команды BX24.js: страница приложения шлёт\n * команду родительскому окну портала через postMessage, портал отвечает\n * сообщением с тем же callbackId.\n *\n * ВНИМАНИЕ: протокол внутренний и недокументированный — Bitrix24 может\n * изменить его без предупреждения. Транспорт повторяет BX24.js\n * (https://api.bitrix24.com/api/v1/, скачан 2026-10-29, Last-Modified\n * 2022-03-17, sha256 945ad491df8ffb7490b89f4914a439b5a3f575c950c3480562815716a3e07f23)\n * и сверен с ответной стороной портала — `/bitrix/js/rest/applayout.js`\n * (Last-Modified 2024-05-15, sha256 3efd6ab57a4778493a26d10ae0987a82e19fc012ed9935f5c6afa78c4052fcb5).\n * Всё знание о протоколе — только в этом модуле (`services/frame`).\n */\n\nexport type BXRestFrameErrorCode =\n  'NOT_IN_FRAME' | 'TIMEOUT' | 'NO_AUTH' | 'BAD_RESPONSE' | 'CANCELLED' | 'ACCESS_DENIED'\n\n/**\n * Ошибка обращения к порталу из iframe. `code`:\n * - `NOT_IN_FRAME` — страница открыта не в iframe приложения Bitrix24;\n * - `TIMEOUT` — портал не ответил за отведённое время;\n * - `NO_AUTH` — портал ответил без токена;\n * - `BAD_RESPONSE` — ответ портала не удалось разобрать;\n * - `CANCELLED` — ожидание отменено через `signal` или новым вызовом того же диалога;\n * - `ACCESS_DENIED` — команда доступна только администратору портала.\n */\nexport class BXRestFrameError extends Error {\n  constructor(\n    public readonly code: BXRestFrameErrorCode,\n    message: string\n  ) {\n    super(message)\n    this.name = 'BXRestFrameError'\n  }\n}\n\nexport interface FrameRequestOptions {\n  /** Сколько ждать ответа, мс; `false` — без ограничения (диалоги, слайдеры). */\n  timeout: number | false\n  /**\n   * Что делать, если портал не ответил за `timeout`: `'reject'` — ошибка\n   * `TIMEOUT` (по умолчанию), `'resolve'` — завершиться с `undefined`.\n   */\n  onTimeout?: 'reject' | 'resolve'\n  signal?: AbortSignal\n}\n\ninterface PortalFrame {\n  /** Как его отдаёт портал, без `:80`/`:443`. */\n  domain: string\n  /** `https://домен` — targetOrigin команд и ожидаемый origin ответов. */\n  origin: string\n  appSid: string\n}\n\n/**\n * Параметры портала (DOMAIN, PROTOCOL, APP_SID) читаются в конструкторе —\n * так же, как это делает BX24.js, из `window.name`: портал задаёт имя\n * iframe приложения в виде `DOMAIN|PROTOCOL|APP_SID`. Если там их нет —\n * из query страницы (`?DOMAIN=…&PROTOCOL=…&APP_SID=…`), с которым портал\n * открывает обработчик приложения. Конструктор не бросает исключений:\n * вне iframe ошибку вернут сами команды.\n */\nexport class FrameTransport {\n\n  private readonly frame: PortalFrame | undefined\n\n  constructor() {\n    this.frame = readPortalFrame()\n  }\n\n  /** Домен портала из параметров фрейма — как `BX24.getDomain()`. */\n  get domain(): string {\n    return this.frame?.domain ?? ''\n  }\n\n  /**\n   * Команда, на которую портал не отвечает (`reloadWindow`, `imCallTo`, ...).\n   * Вне iframe бросает `BXRestFrameError` с кодом `NOT_IN_FRAME`.\n   */\n  post(command: string, params: unknown): void {\n    this.send(this.requireFrame(), command, params, '')\n  }\n\n  /** Команда с одним ответом портала. */\n  request(command: string, params: unknown, options: FrameRequestOptions): Promise<unknown> {\n    return new Promise((resolve, reject) => {\n      let frame: PortalFrame\n      try {\n        frame = this.requireFrame()\n      } catch (error) {\n        reject(error)\n        return\n      }\n      const { timeout, onTimeout = 'reject', signal } = options\n      if (signal?.aborted) {\n        reject(cancelled(command))\n        return\n      }\n\n      const callbackId = uniqId()\n      let timer: ReturnType<typeof setTimeout> | undefined\n      const finish = () => {\n        clearTimeout(timer)\n        stopListening()\n        signal?.removeEventListener('abort', onAbort)\n      }\n      const onAbort = () => {\n        finish()\n        reject(cancelled(command))\n      }\n      const stopListening = this.listen(frame, callbackId, payload => {\n        finish()\n        const answer = parsePayload(payload)\n        if (answer.ok) {\n          resolve(answer.value)\n        } else {\n          // В тексте ошибки — только команда, без тела ответа: в нём бывают токены\n          reject(new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} with a payload that is not JSON.`))\n        }\n      })\n\n      if (timeout !== false) {\n        timer = setTimeout(() => {\n          finish()\n          if (onTimeout === 'resolve') {\n            resolve(undefined)\n          } else {\n            reject(new BXRestFrameError('TIMEOUT', [\n              `Bitrix24 did not answer ${command} within ${timeout} ms:`,\n              'the page is not opened inside a Bitrix24 portal iframe, or the portal could not process the command.'\n            ].join(' ')))\n          }\n        }, timeout)\n      }\n      signal?.addEventListener('abort', onAbort, { once: true })\n\n      this.send(frame, command, params, callbackId)\n    })\n  }\n\n  /**\n   * Команда, на которую портал отвечает многократно (`placementBindEvent`):\n   * `handler` вызывается на каждый ответ. Возвращает функцию отписки —\n   * она только перестаёт слушать: отменить подписку на стороне портала\n   * протокол не позволяет. Вне iframe бросает `BXRestFrameError`.\n   */\n  subscribe(command: string, params: unknown, handler: (data: unknown) => void): () => void {\n    const frame = this.requireFrame()\n    const callbackId = uniqId()\n    const stopListening = this.listen(frame, callbackId, payload => {\n      const answer = parsePayload(payload)\n      if (answer.ok) {\n        handler(answer.value)\n      }\n    })\n    this.send(frame, command, params, callbackId)\n    return stopListening\n  }\n\n  private requireFrame(): PortalFrame {\n    if (!this.frame) {\n      throw new BXRestFrameError('NOT_IN_FRAME',\n        'Bitrix24 frame parameters (DOMAIN, APP_SID) were not found in window.name or in the URL query: '\n        + 'the page is not opened as a Bitrix24 application.')\n    }\n    if (window.parent === window) {\n      throw new BXRestFrameError('NOT_IN_FRAME',\n        'The page is not opened inside an iframe, so there is no Bitrix24 portal to send commands to.')\n    }\n    return this.frame\n  }\n\n  /**\n   * Формат — как у BX24.js. Обычно строка `команда:параметры:callbackId:APP_SID`\n   * (портал разбирает её с конца, поэтому параметры и callbackId могут быть\n   * пустыми); для команд с `:` в имени — объект.\n   */\n  private send(frame: PortalFrame, command: string, params: unknown, callbackId: string): void {\n    const message = command.includes(':')\n      ? { method: command, params: params ? params : '', callback: callbackId, appSid: frame.appSid }\n      : `${command}:${params ? JSON.stringify(params) : ''}:${callbackId}:${frame.appSid}`\n    window.parent.postMessage(message, frame.origin)\n  }\n\n  /** Ответ портала — строка `callbackId:JSON` (или `callbackId:`, если ответ пустой). */\n  private listen(frame: PortalFrame, callbackId: string, onAnswer: (payload: string) => void): () => void {\n    const portalWindow = window.parent\n    const onMessage = (event: MessageEvent) => {\n      // Ответ принимаем только от родительского окна и только с origin\n      // портала — BX24.js проверяет лишь origin\n      if (event.source !== portalWindow || event.origin !== frame.origin || typeof event.data !== 'string') {\n        return\n      }\n      const separator = event.data.indexOf(':')\n      const id = separator < 0 ? event.data : event.data.slice(0, separator)\n      if (id === callbackId) {\n        onAnswer(separator < 0 ? '' : event.data.slice(separator + 1))\n      }\n    }\n    window.addEventListener('message', onMessage)\n    return () => window.removeEventListener('message', onMessage)\n  }\n}\n\nfunction parsePayload(payload: string): { ok: true, value: unknown } | { ok: false } {\n  if (payload === '') {\n    return { ok: true, value: undefined }\n  }\n  try {\n    return { ok: true, value: JSON.parse(payload) }\n  } catch {\n    return { ok: false }\n  }\n}\n\nfunction cancelled(command: string): BXRestFrameError {\n  return new BXRestFrameError('CANCELLED', `Waiting for the Bitrix24 answer to ${command} was cancelled.`)\n}\n\nfunction readPortalFrame(): PortalFrame | undefined {\n  if (typeof window === 'undefined') {\n    return undefined\n  }\n\n  // BX24.js: window.name = 'DOMAIN|PROTOCOL|APP_SID'\n  const [nameDomain, nameProtocol, nameAppSid] = (typeof window.name === 'string' ? window.name : '').split('|')\n  const fromName = toPortalFrame(nameDomain, nameProtocol, nameAppSid)\n  if (fromName) {\n    return fromName\n  }\n\n  try {\n    const query = new URLSearchParams(window.location?.search ?? '')\n    return toPortalFrame(query.get('DOMAIN'), query.get('PROTOCOL'), query.get('APP_SID'))\n  } catch {\n    return undefined\n  }\n}\n\nfunction toPortalFrame(\n  rawDomain: string | null | undefined,\n  rawProtocol: string | null | undefined,\n  appSid: string | null | undefined\n): PortalFrame | undefined {\n  // Как BX24.js: порт по умолчанию отрезается, PROTOCOL 1 — https\n  const domain = (rawDomain ?? '').replace(/:(80|443)$/, '')\n  if (!domain || !appSid) {\n    return undefined\n  }\n  const protocol = (Number.parseInt(rawProtocol ?? '', 10) || 0) ? 'https' : 'http'\n\n  try {\n    const url = new URL(`${protocol}://${domain}`)\n    // В DOMAIN должен быть только хост (и порт) — никаких путей и логинов\n    if (url.host !== domain.toLowerCase() || url.username || url.password) {\n      return undefined\n    }\n    return { domain, origin: url.origin, appSid }\n  } catch {\n    return undefined\n  }\n}\n\nfunction uniqId(): string {\n  const bytes = new Uint8Array(16)\n  globalThis.crypto.getRandomValues(bytes)\n  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('')\n}\n"]}

package/esm2022/services/frame/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/http/HttpBX.mjs

@@ -6,6 +6,7 @@ import { instanceOfiBXRestAnswerSuccess } from '../../functions/mapResult';
 import { switchMap } from 'rxjs/operators';
 import { prepareBaseAddress } from '../base';
 import { serializeBitrixParams as stringifyBitrixParams } from '../../functions/serializeBitrixParams';
+import { withAuthRefresh } from './authRefresh';
 export class HttpBXServices extends HttpServices {
     /**
      * Не считайте этот метод образцом/финальным API.
@@ -53,27 +54,38 @@ export class HttpBXServices extends HttpServices {
      *
      * @param name
      * @param params
+     * @param restApi
+     * @param headers заголовки только для этого запроса, поверх `BXRestSettings.headers`
      */
-    post(name, params = {}, restApi = false) {
+    post(name, params = {}, restApi = false, headers) {
         const method = this.getNameMethod(name);
-        return this.httpPost(restApi ? `api/${method}` : method, params);
+        return this.httpPost(restApi ? `api/${method}` : method, params, undefined, headers);
     }
     /**
      * Второстепенный метод для запросов. По возможности лучше не использовать
      *
      * @param name
      * @param params
+     * @param headers заголовки только для этого запроса, поверх `BXRestSettings.headers`
      */
-    get(name, params = {}) {
-        return this.httpGet(this.getNameMethod(name), params);
+    get(name, params = {}, headers) {
+        return this.httpGet(this.getNameMethod(name), params, undefined, headers);
     }
-    httpPost(url, params = {}) {
+    // settings — только для совместимости сигнатуры с HttpServices: здесь тело
+    // уходит JSON-ом/urlencoded, и пересчёт дат из iHttpParamSettings не нужен.
+    httpPost(url, params = {}, settings, headers) {
         // defer() откладывает всё содержимое (в том числе чтение BXRestSettings
         // через this.session.*) до реальной подписки — иначе даже с "живым"
         // геттером в SessionKeyServices настройки читались бы в момент вызова
         // .res(), а не в момент subscribe()/firstValueFrom(), что и обещано
         // в README как поведение "ленивого" REST-вызова.
-        return defer(() => {
+        //
+        // withAuthRefresh() повторяет запрос после BXRestSettings.auth.refresh —
+        // повторной подпиской на этот же defer(), поэтому повтор заново читает
+        // токен, адрес и заголовки. Через httpPost/httpGet идут все запросы
+        // библиотеки (post/get, batch, все виды Navvy-запросов), так что повтор
+        // встроен только здесь.
+        return withAuthRefresh(defer(() => {
             const paramsClone = clone(params);
             const key = this.session.getKeyAuth();
             const auth = this.session.getAuthParams();
@@ -95,24 +107,23 @@ export class HttpBXServices extends HttpServices {
                     // Преобразуем параметры в формат x-www-form-urlencoded
                     const bodyString = this.serializeBitrixParams(paramsClone);
                     return from(this.axiosInstance.post(fullUrl, bodyString, {
-                        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                        headers: this.buildHeaders(headers, { 'Content-Type': 'application/x-www-form-urlencoded' }),
                     }).then((response) => response.data));
                 }
                 return from(this.axiosInstance.post(fullUrl, paramsClone, {
                     withCredentials: this.session.getWithCredentials(),
-                    headers: {
-                        'Content-Type': 'application/json',
-                    }
+                    headers: this.buildHeaders(headers, { 'Content-Type': 'application/json' }),
                 }).then((response) => response.data));
             }));
-        });
+        }));
     }
-    httpGet(url, params = {}) {
+    httpGet(url, params = {}, settings, headers) {
         // Та же причина, что и у httpPost выше: откладываем чтение BXRestSettings
         // до подписки, чтобы `get()` вёл себя так же "лениво", как и `post()`
         // (симметрия, которой не было до этого — GET резолвил настройки в момент
-        // вызова, а не в момент subscribe()).
-        return defer(() => {
+        // вызова, а не в момент subscribe()). Повтор после продления
+        // авторизации — как в httpPost.
+        return withAuthRefresh(defer(() => {
             const paramsClone = clone(params);
             const auth = this.session.getAuthParams();
             const checkIsOn = this.session.getCheckAuthParamsIsOn();
@@ -129,9 +140,20 @@ export class HttpBXServices extends HttpServices {
                 const fullUrl = prepareBaseAddress(baseUrl) + url;
                 const queryString = new URLSearchParams(paramsClone).toString();
                 const finalUrl = `${fullUrl}?${queryString}`;
-                return from(this.axiosInstance.get(finalUrl).then((response) => response.data));
+                return from(this.axiosInstance.get(finalUrl, {
+                    headers: this.buildHeaders(headers),
+                }).then((response) => response.data));
             }));
-        });
+        }));
+    }
+    /**
+     * Заголовки запроса: `BXRestSettings.headers`, поверх них — заголовки
+     * конкретного запроса, поверх всего — `required`. В `required` идёт
+     * `Content-Type`: от него зависит, как сервер разберёт тело, поэтому
+     * пользовательские заголовки его не перебивают.
+     */
+    buildHeaders(headers, required = {}) {
+        return { ...this.session.getHeaders(), ...headers, ...required };
     }
     serializeBitrixParams(params) {
         return stringifyBitrixParams(params);
@@ -140,4 +162,4 @@ export class HttpBXServices extends HttpServices {
         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, defer } 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'\r\nimport { prepareBaseAddress } from '../base'\r\nimport { serializeBitrixParams as stringifyBitrixParams } from '../../functions/serializeBitrixParams'\r\n\r\nexport class HttpBXServices extends HttpServices {\r\n\r\n  /**\r\n   * Не считайте этот метод образцом/финальным API.\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)\r\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 = {}, restApi = false) {\r\n    const method = this.getNameMethod(name)\r\n    return this.httpPost<iBXRestAnswer<T>>(restApi ? `api/${method}` : method, 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> {\r\n    // defer() откладывает всё содержимое (в том числе чтение BXRestSettings\r\n    // через this.session.*) до реальной подписки — иначе даже с \"живым\"\r\n    // геттером в SessionKeyServices настройки читались бы в момент вызова\r\n    // .res(), а не в момент subscribe()/firstValueFrom(), что и обещано\r\n    // в README как поведение \"ленивого\" REST-вызова.\r\n    return defer(() => {\r\n      const paramsClone = clone(params)\r\n      const key = this.session.getKeyAuth()\r\n      const auth = this.session.getAuthParams()\r\n      const checkIsOn = this.session.getCheckAuthParamsIsOn()\r\n\r\n      if (checkIsOn) {\r\n        if (!auth) {\r\n          return throwError(() => this.session.getAuthError('post'))\r\n        }\r\n\r\n        if (key !== 'OAuth2') {\r\n          paramsClone[key] = auth\r\n        }\r\n      }\r\n\r\n      return this.session.getBaseUrl().pipe(\r\n        switchMap((baseUrl) => {\r\n          if (!baseUrl) {\r\n            return throwError(() => this.session.getBaseUrlError('post'))\r\n          }\r\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)\r\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: this.session.getWithCredentials(),\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    })\r\n  }\r\n\r\n  override httpGet<T>(url: string, params: any = {}): Observable<T | undefined> {\r\n    // Та же причина, что и у httpPost выше: откладываем чтение BXRestSettings\r\n    // до подписки, чтобы `get()` вёл себя так же \"лениво\", как и `post()`\r\n    // (симметрия, которой не было до этого — GET резолвил настройки в момент\r\n    // вызова, а не в момент subscribe()).\r\n    return defer(() => {\r\n      const paramsClone = clone(params)\r\n      const auth = this.session.getAuthParams()\r\n      const checkIsOn = this.session.getCheckAuthParamsIsOn()\r\n\r\n      if (checkIsOn) {\r\n        if (!auth) {\r\n          return throwError(() => this.session.getAuthError('get'))\r\n        }\r\n\r\n        paramsClone[this.session.getKeyAuth()] = auth\r\n      }\r\n\r\n      return this.session.getBaseUrl().pipe(\r\n        switchMap((baseUrl) => {\r\n          if (!baseUrl) {\r\n            return throwError(() => this.session.getBaseUrlError('get'))\r\n          }\r\n\r\n          const fullUrl = prepareBaseAddress(baseUrl) + url\r\n          const queryString = new URLSearchParams(paramsClone).toString()\r\n          const finalUrl = `${fullUrl}?${queryString}`\r\n\r\n          return from(\r\n            this.axiosInstance.get<T>(finalUrl).then((response) => response.data)\r\n          )\r\n        })\r\n      )\r\n    })\r\n  }\r\n\r\n  serializeBitrixParams(params: unknown): string {\r\n    return stringifyBitrixParams(params)\r\n  }\r\n\r\n  getNameMethod(arr: string[]) {\r\n    return arr.join('.')\r\n  }\r\n\r\n}\r\n\r\n"]}
+//# 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, defer } 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'\r\nimport { prepareBaseAddress } from '../base'\r\nimport { serializeBitrixParams as stringifyBitrixParams } from '../../functions/serializeBitrixParams'\r\nimport { iHttpParamSettings } from '../../typification/rest/settings'\r\nimport { withAuthRefresh } from './authRefresh'\r\n\r\nexport class HttpBXServices extends HttpServices {\r\n\r\n  /**\r\n   * Не считайте этот метод образцом/финальным API.\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)\r\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   * @param restApi\r\n   * @param headers заголовки только для этого запроса, поверх `BXRestSettings.headers`\r\n   */\r\n  post<T>(name: string[], params: any = {}, restApi = false, headers?: Record<string, string>) {\r\n    const method = this.getNameMethod(name)\r\n    return this.httpPost<iBXRestAnswer<T>>(restApi ? `api/${method}` : method, params, undefined, headers)\r\n  }\r\n\r\n  /**\r\n   * Второстепенный метод для запросов. По возможности лучше не использовать\r\n   *\r\n   * @param name\r\n   * @param params\r\n   * @param headers заголовки только для этого запроса, поверх `BXRestSettings.headers`\r\n   */\r\n  get<T>(name: string[], params: any = {}, headers?: Record<string, string>) {\r\n    return this.httpGet<iBXRestAnswer<T>>(this.getNameMethod(name), params, undefined, headers)\r\n  }\r\n\r\n  // settings — только для совместимости сигнатуры с HttpServices: здесь тело\r\n  // уходит JSON-ом/urlencoded, и пересчёт дат из iHttpParamSettings не нужен.\r\n  override httpPost<T>(\r\n    url: string,\r\n    params: any = {},\r\n    settings?: iHttpParamSettings,\r\n    headers?: Record<string, string>\r\n  ): Observable<T | undefined> {\r\n    // defer() откладывает всё содержимое (в том числе чтение BXRestSettings\r\n    // через this.session.*) до реальной подписки — иначе даже с \"живым\"\r\n    // геттером в SessionKeyServices настройки читались бы в момент вызова\r\n    // .res(), а не в момент subscribe()/firstValueFrom(), что и обещано\r\n    // в README как поведение \"ленивого\" REST-вызова.\r\n    //\r\n    // withAuthRefresh() повторяет запрос после BXRestSettings.auth.refresh —\r\n    // повторной подпиской на этот же defer(), поэтому повтор заново читает\r\n    // токен, адрес и заголовки. Через httpPost/httpGet идут все запросы\r\n    // библиотеки (post/get, batch, все виды Navvy-запросов), так что повтор\r\n    // встроен только здесь.\r\n    return withAuthRefresh(defer(() => {\r\n      const paramsClone = clone(params)\r\n      const key = this.session.getKeyAuth()\r\n      const auth = this.session.getAuthParams()\r\n      const checkIsOn = this.session.getCheckAuthParamsIsOn()\r\n\r\n      if (checkIsOn) {\r\n        if (!auth) {\r\n          return throwError(() => this.session.getAuthError('post'))\r\n        }\r\n\r\n        if (key !== 'OAuth2') {\r\n          paramsClone[key] = auth\r\n        }\r\n      }\r\n\r\n      return this.session.getBaseUrl().pipe(\r\n        switchMap((baseUrl) => {\r\n          if (!baseUrl) {\r\n            return throwError(() => this.session.getBaseUrlError('post'))\r\n          }\r\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)\r\n            return from(\r\n              this.axiosInstance.post<T>(fullUrl, bodyString, {\r\n                headers: this.buildHeaders(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: this.session.getWithCredentials(),\r\n                headers: this.buildHeaders(headers, {'Content-Type': 'application/json'}),\r\n              }\r\n            ).then((response) => response.data)\r\n          )\r\n        })\r\n      )\r\n    }))\r\n  }\r\n\r\n  override httpGet<T>(\r\n    url: string,\r\n    params: any = {},\r\n    settings?: iHttpParamSettings,\r\n    headers?: Record<string, string>\r\n  ): Observable<T | undefined> {\r\n    // Та же причина, что и у httpPost выше: откладываем чтение BXRestSettings\r\n    // до подписки, чтобы `get()` вёл себя так же \"лениво\", как и `post()`\r\n    // (симметрия, которой не было до этого — GET резолвил настройки в момент\r\n    // вызова, а не в момент subscribe()). Повтор после продления\r\n    // авторизации — как в httpPost.\r\n    return withAuthRefresh(defer(() => {\r\n      const paramsClone = clone(params)\r\n      const auth = this.session.getAuthParams()\r\n      const checkIsOn = this.session.getCheckAuthParamsIsOn()\r\n\r\n      if (checkIsOn) {\r\n        if (!auth) {\r\n          return throwError(() => this.session.getAuthError('get'))\r\n        }\r\n\r\n        paramsClone[this.session.getKeyAuth()] = auth\r\n      }\r\n\r\n      return this.session.getBaseUrl().pipe(\r\n        switchMap((baseUrl) => {\r\n          if (!baseUrl) {\r\n            return throwError(() => this.session.getBaseUrlError('get'))\r\n          }\r\n\r\n          const fullUrl = prepareBaseAddress(baseUrl) + url\r\n          const queryString = new URLSearchParams(paramsClone).toString()\r\n          const finalUrl = `${fullUrl}?${queryString}`\r\n\r\n          return from(\r\n            this.axiosInstance.get<T>(finalUrl, {\r\n              headers: this.buildHeaders(headers),\r\n            }).then((response) => response.data)\r\n          )\r\n        })\r\n      )\r\n    }))\r\n  }\r\n\r\n  /**\r\n   * Заголовки запроса: `BXRestSettings.headers`, поверх них — заголовки\r\n   * конкретного запроса, поверх всего — `required`. В `required` идёт\r\n   * `Content-Type`: от него зависит, как сервер разберёт тело, поэтому\r\n   * пользовательские заголовки его не перебивают.\r\n   */\r\n  private buildHeaders(headers?: Record<string, string>, required: Record<string, string> = {}) {\r\n    return { ...this.session.getHeaders(), ...headers, ...required }\r\n  }\r\n\r\n  serializeBitrixParams(params: unknown): string {\r\n    return stringifyBitrixParams(params)\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/authRefresh.mjs

@@ -0,0 +1,89 @@
+import { defer, from, throwError } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import axios from 'axios';
+import { BXRestSettings } from '../../settings';
+import { parseBXRestErrorBody } from '../../functions/errors';
+/**
+ * Коды ошибок Bitrix, которые лечатся продлением токена. `expired_token` —
+ * единственный системный код, для которого документация Bitrix24 советует
+ * "обновить токены и повторить вызов". `invalid_token` в списке системных
+ * ошибок документации нет, но так же считает официальный `@bitrix24/b24jssdk`.
+ *
+ * Остальные системные ошибки тоже приходят со статусом 401
+ * (`insufficient_scope`, `NO_AUTH_FOUND`, `ACCESS_DENIED`,
+ * `INVALID_CREDENTIALS`, `user_access_error`, ...), но новый токен их
+ * не исправит — поэтому смотрим на код, а не только на статус.
+ */
+const AUTH_ERROR_CODES = ['expired_token', 'invalid_token'];
+/**
+ * Условие продления по умолчанию (`BXRestSettings.auth.isAuthError`):
+ * - ответ с ошибкой Bitrix `expired_token` или `invalid_token` — при любом статусе;
+ * - ответ 401 без тела ошибки Bitrix — например, пустой ответ своего
+ *   бэкенд-прокси, у которого нет действующего токена.
+ *
+ * Ответ 401 с другим кодом Bitrix ошибкой авторизации не считается.
+ */
+export function isBXRestAuthError(error) {
+    if (!axios.isAxiosError(error) || !error.response) {
+        return false;
+    }
+    const parsed = parseBXRestErrorBody(error.response.data);
+    if (parsed) {
+        return AUTH_ERROR_CODES.includes(parsed.error);
+    }
+    return error.response.status === 401;
+}
+// Общее на всю библиотеку состояние продления — как и сами BXRestSettings.
+// pendingRefresh — идущее сейчас продление, его ждут все упавшие запросы;
+// refreshCount — сколько продлений уже завершилось успешно.
+let pendingRefresh;
+let refreshCount = 0;
+function sharedRefresh(refresh) {
+    if (!pendingRefresh) {
+        pendingRefresh = Promise.resolve()
+            // Через then, чтобы синхронное исключение в refresh() тоже стало
+            // отклонённым промисом, а не вылетело из catchError
+            .then(() => refresh())
+            .then(() => {
+            refreshCount++;
+        })
+            .finally(() => {
+            pendingRefresh = undefined;
+        });
+    }
+    return pendingRefresh;
+}
+/**
+ * Повтор запроса после продления авторизации (`BXRestSettings.auth.refresh`).
+ *
+ * `request$` должен быть "холодным" и читать настройки при подписке (как
+ * `defer()` в HttpBXServices): повтор — это повторная подписка, поэтому
+ * токен, адрес и заголовки берутся уже новые. На второй попытке ошибка не
+ * перехватывается — запрос повторяется не больше одного раза.
+ */
+export function withAuthRefresh(request$) {
+    return defer(() => {
+        const { refresh, isAuthError = isBXRestAuthError } = BXRestSettings.value.auth;
+        if (!refresh) {
+            return request$;
+        }
+        const refreshCountAtStart = refreshCount;
+        return request$.pipe(catchError((error) => {
+            if (!isAuthError(error)) {
+                return throwError(() => error);
+            }
+            // Пока этот запрос был в пути, токен уже продлили по ошибке другого
+            // запроса — повторяем без нового продления
+            const refreshed = (refreshCount !== refreshCountAtStart)
+                ? Promise.resolve()
+                : sharedRefresh(refresh);
+            return from(refreshed).pipe(catchError((refreshError) => {
+                if (error && typeof error === 'object') {
+                    error.authRefreshError = refreshError;
+                }
+                return throwError(() => error);
+            }), switchMap(() => request$));
+        }));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authRefresh.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/http/authRefresh.ts"],"names":[],"mappings":"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","sourcesContent":["import { defer, from, Observable, throwError } from 'rxjs'\nimport { catchError, switchMap } from 'rxjs/operators'\nimport axios from 'axios'\nimport { BXRestSettings } from '../../settings'\nimport { parseBXRestErrorBody } from '../../functions/errors'\n\n/**\n * Коды ошибок Bitrix, которые лечатся продлением токена. `expired_token` —\n * единственный системный код, для которого документация Bitrix24 советует\n * \"обновить токены и повторить вызов\". `invalid_token` в списке системных\n * ошибок документации нет, но так же считает официальный `@bitrix24/b24jssdk`.\n *\n * Остальные системные ошибки тоже приходят со статусом 401\n * (`insufficient_scope`, `NO_AUTH_FOUND`, `ACCESS_DENIED`,\n * `INVALID_CREDENTIALS`, `user_access_error`, ...), но новый токен их\n * не исправит — поэтому смотрим на код, а не только на статус.\n */\nconst AUTH_ERROR_CODES = ['expired_token', 'invalid_token']\n\n/**\n * Условие продления по умолчанию (`BXRestSettings.auth.isAuthError`):\n * - ответ с ошибкой Bitrix `expired_token` или `invalid_token` — при любом статусе;\n * - ответ 401 без тела ошибки Bitrix — например, пустой ответ своего\n *   бэкенд-прокси, у которого нет действующего токена.\n *\n * Ответ 401 с другим кодом Bitrix ошибкой авторизации не считается.\n */\nexport function isBXRestAuthError(error: unknown): boolean {\n  if (!axios.isAxiosError(error) || !error.response) {\n    return false\n  }\n  const parsed = parseBXRestErrorBody(error.response.data)\n  if (parsed) {\n    return AUTH_ERROR_CODES.includes(parsed.error)\n  }\n  return error.response.status === 401\n}\n\n// Общее на всю библиотеку состояние продления — как и сами BXRestSettings.\n// pendingRefresh — идущее сейчас продление, его ждут все упавшие запросы;\n// refreshCount — сколько продлений уже завершилось успешно.\nlet pendingRefresh: Promise<void> | undefined\nlet refreshCount = 0\n\nfunction sharedRefresh(refresh: () => Promise<unknown>): Promise<void> {\n  if (!pendingRefresh) {\n    pendingRefresh = Promise.resolve()\n      // Через then, чтобы синхронное исключение в refresh() тоже стало\n      // отклонённым промисом, а не вылетело из catchError\n      .then(() => refresh())\n      .then(() => {\n        refreshCount++\n      })\n      .finally(() => {\n        pendingRefresh = undefined\n      })\n  }\n  return pendingRefresh\n}\n\n/**\n * Повтор запроса после продления авторизации (`BXRestSettings.auth.refresh`).\n *\n * `request$` должен быть \"холодным\" и читать настройки при подписке (как\n * `defer()` в HttpBXServices): повтор — это повторная подписка, поэтому\n * токен, адрес и заголовки берутся уже новые. На второй попытке ошибка не\n * перехватывается — запрос повторяется не больше одного раза.\n */\nexport function withAuthRefresh<T>(request$: Observable<T>): Observable<T> {\n  return defer(() => {\n    const { refresh, isAuthError = isBXRestAuthError } = BXRestSettings.value.auth\n    if (!refresh) {\n      return request$\n    }\n\n    const refreshCountAtStart = refreshCount\n    return request$.pipe(\n      catchError((error: unknown) => {\n        if (!isAuthError(error)) {\n          return throwError(() => error)\n        }\n        // Пока этот запрос был в пути, токен уже продлили по ошибке другого\n        // запроса — повторяем без нового продления\n        const refreshed = (refreshCount !== refreshCountAtStart)\n          ? Promise.resolve()\n          : sharedRefresh(refresh)\n\n        return from(refreshed).pipe(\n          catchError((refreshError: unknown) => {\n            if (error && typeof error === 'object') {\n              (error as { authRefreshError?: unknown }).authRefreshError = refreshError\n            }\n            return throwError(() => error)\n          }),\n          switchMap(() => request$)\n        )\n      })\n    )\n  })\n}\n"]}