bx-rest 1.3.0 → 1.4.0

package/esm2022/services/frame/frame.mjs

@@ -0,0 +1,347 @@
+import { BXRestFrameError, FrameTransport } from './transport';
+const DEFAULT_TIMEOUT = 10000;
+/**
+ * Команды порталу Bitrix24 из iframe приложения — без подключения BX24.js.
+ * Те же команды и те же имена, что у BX24.js, но вместо колбэков —
+ * промисы. Протокол внутренний и недокументированный, см. `transport.ts`.
+ *
+ * Создавайте один экземпляр на страницу и при старте приложения: параметры
+ * портала читаются в конструкторе (до того, как роутер перепишет адрес), а
+ * `firstRun` портал сообщает только в первом ответе на `getInitData`.
+ *
+ * Токены класс не логирует и никуда не сохраняет: `getAuth()` и
+ * `refreshAuth()` каждый раз спрашивают портал, а в `init()` токенов нет.
+ *
+ * @example
+ * const frame = new BXRestFrame()
+ * const { lang, placement } = await frame.init()
+ * await frame.fitWindow()
+ * const user = await frame.selectUser()
+ */
+export class BXRestFrame {
+    constructor(options = {}) {
+        this.transport = new FrameTransport();
+        // Открытый диалог каждого вида — новый вызов того же диалога отменяет прошлый
+        this.dialogs = new Map();
+        /** Мессенджер — как `BX24.im`. Портал на эти команды не отвечает. */
+        this.im = {
+            /** Позвонить сотруднику — `BX24.im.callTo()`. */
+            callTo: async (userId, video) => {
+                this.transport.post('imCallTo', { userId, video });
+            },
+            /** Позвонить на телефон — `BX24.im.phoneTo()`. */
+            phoneTo: async (phone) => {
+                this.transport.post('imPhoneTo', { phone });
+            },
+            /** Открыть чат — `BX24.im.openMessenger()`. */
+            openMessenger: async (dialogId) => {
+                this.transport.post('imOpenMessenger', { dialogId });
+            },
+            /** Открыть историю чата — `BX24.im.openHistory()`. */
+            openHistory: async (dialogId) => {
+                this.transport.post('imOpenHistory', { dialogId });
+            },
+        };
+        /** Встраивание — как `BX24.placement`. */
+        this.placement = {
+            /** Код и параметры встраивания — `BX24.placement.info()`. */
+            info: async () => {
+                const { placement, placementOptions } = await this.init();
+                return { placement, options: placementOptions };
+            },
+            /** Команды и события текущего встраивания — `BX24.placement.getInterface()`. */
+            getInterface: async () => {
+                return await this.transport.request('getInterface', null, { timeout: this.timeout });
+            },
+            /**
+             * Команда встраивания — `BX24.placement.call()`. Набор команд зависит от
+             * встраивания (см. `getInterface()`). Не на все команды портал отвечает:
+             * без ответа за `timeout` промис завершается с `undefined`.
+             */
+            call: async (command, params, options = {}) => {
+                return this.transport.request(command, params, {
+                    timeout: options.timeout ?? this.timeout,
+                    onTimeout: 'resolve',
+                });
+            },
+            /**
+             * Подписка на событие встраивания — `BX24.placement.bindEvent()`.
+             * `handler` вызывается при каждом событии. Возвращает функцию отписки:
+             * она только перестаёт вызывать `handler` — отменить подписку на
+             * стороне портала протокол не позволяет. Вне iframe бросает
+             * `BXRestFrameError` с кодом `NOT_IN_FRAME`.
+             */
+            bindEvent: (event, handler) => {
+                return this.transport.subscribe('placementBindEvent', { event }, handler);
+            },
+        };
+        /** Настройки приложения для текущего пользователя — как `BX24.userOption`. */
+        this.userOption = {
+            get: async (name) => (await this.init()).userOptions[name],
+            set: async (name, value) => {
+                const init = await this.init();
+                init.userOptions[name] = value;
+                await this.ack('setUserOption', { name, value });
+            },
+        };
+        /** Настройки приложения для всего портала — как `BX24.appOption`. */
+        this.appOption = {
+            get: async (name) => (await this.init()).appOptions[name],
+            /**
+             * Менять их может только администратор портала: остальным — ошибка
+             * `ACCESS_DENIED` (BX24.js в этом случае молча ничего не делает).
+             * Возвращает настройки приложения после сохранения.
+             */
+            set: async (name, value) => {
+                const init = await this.init();
+                if (!init.isAdmin) {
+                    throw new BXRestFrameError('ACCESS_DENIED', 'Only a Bitrix24 administrator can change application options.');
+                }
+                init.appOptions[name] = value;
+                return await this.transport.request('setAppOption', { name, value }, { timeout: this.timeout });
+            },
+        };
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    }
+    /**
+     * Данные запуска приложения — аналог `BX24.init()`: язык, домен, права,
+     * встраивание, настройки, признаки установки. Запрашиваются у портала
+     * один раз, дальше берутся из памяти. Токенов здесь нет — см. `getAuth()`.
+     */
+    init() {
+        if (this.initValue) {
+            return Promise.resolve(this.initValue);
+        }
+        if (!this.initRequest) {
+            this.initRequest = this.getInitData()
+                .then(() => this.initValue)
+                .finally(() => {
+                this.initRequest = undefined;
+            });
+        }
+        return this.initRequest;
+    }
+    /**
+     * Текущая авторизация приложения — аналог `BX24.getAuth()`. Каждый вызов —
+     * новый запрос `getInitData` к порталу.
+     *
+     * `expires_in` портал считает от срока жизни токена в момент выдачи, а не
+     * от остатка: если страница открыта давно, значение будет завышено (так
+     * же и у BX24.js). Для свежего токена используйте `refreshAuth()`.
+     */
+    async getAuth() {
+        const data = await this.getInitData();
+        return this.toAuth('getInitData', data, String(data['MEMBER_ID'] || ''));
+    }
+    /**
+     * Новая авторизация приложения — аналог `BX24.refreshAuth()`: портал
+     * выпускает новую пару `access_token`/`refresh_token`. Если портал не может
+     * выдать токен, он показывает `alert` «Unable to get new token!» и не
+     * отвечает — тогда ошибка `TIMEOUT`.
+     */
+    async refreshAuth() {
+        // member_id приходит только в getInitData — refreshAuth его не возвращает
+        const { memberId } = await this.init();
+        const data = asObject('refreshAuth', await this.transport.request('refreshAuth', {}, { timeout: this.timeout }));
+        return this.toAuth('refreshAuth', data, memberId);
+    }
+    /**
+     * Завершить установку — аналог `BX24.installFinish()`: портал отмечает
+     * приложение установленным и перезагружает страницу. Делает что-то только
+     * на странице установщика (`init().install`), иначе — ничего, как и BX24.js.
+     */
+    async installFinish() {
+        if ((await this.init()).install) {
+            this.transport.post('setInstallFinish', {});
+        }
+    }
+    /**
+     * Отметить, что первый запуск у этого пользователя пройден, — то, что
+     * BX24.js делает после последнего обработчика `BX24.install()`. Без этого
+     * `init().firstRun` останется `true` и при следующих запусках. Делает
+     * что-то только при первом запуске.
+     */
+    async firstRunFinish() {
+        const init = await this.init();
+        if (init.firstRun) {
+            await this.ack('setInstall', { install: true });
+            init.firstRun = false;
+        }
+    }
+    /** Задать размер фрейма — `BX24.resizeWindow()`. Возвращает размер, который выставил портал. */
+    async resizeWindow(width, height) {
+        const w = Number.parseInt(String(width), 10);
+        const h = Number.parseInt(String(height), 10);
+        if (!(w > 0 && h > 0)) {
+            throw new TypeError('resizeWindow: width and height must be positive numbers.');
+        }
+        return await this.ack('resizeWindow', { width: w, height: h });
+    }
+    /** Подогнать высоту фрейма под содержимое — `BX24.fitWindow()`. */
+    async fitWindow() {
+        const root = document.documentElement;
+        const height = Math.max(root.scrollHeight, root.offsetHeight);
+        return await this.ack('resizeWindow', { width: '100%', height });
+    }
+    /**
+     * Перезагрузить страницу портала с приложением — `BX24.reloadWindow()`.
+     * Портал на эту команду не отвечает.
+     */
+    async reloadWindow() {
+        this.transport.post('reloadWindow', {});
+    }
+    /** Заголовок страницы портала — `BX24.setTitle()`. */
+    async setTitle(title) {
+        return await this.ack('setTitle', { title: String(title) });
+    }
+    /** Прокрутить страницу портала — `BX24.scrollParentWindow()`. */
+    async scrollParentWindow(scroll) {
+        const value = Number.parseInt(String(scroll), 10);
+        if (Number.isNaN(value)) {
+            throw new TypeError('scrollParentWindow: scroll must be a number.');
+        }
+        return await this.ack('setScroll', { scroll: value });
+    }
+    /**
+     * Диалог выбора одного сотрудника — `BX24.selectUser()`. Ждёт выбора без
+     * ограничения по времени: если пользователь закрыл диалог, портал не
+     * отвечает вовсе. Отменить ожидание — `signal` или новый вызов
+     * `selectUser()`/`selectUsers()` (ошибка `CANCELLED`).
+     */
+    selectUser(options = {}) {
+        return this.dialog('user', 'selectUser', { title: options.title ?? '', mult: false }, options.signal);
+    }
+    /** Диалог выбора нескольких сотрудников — `BX24.selectUsers()`. Ожидание — как у `selectUser()`. */
+    selectUsers(options = {}) {
+        return this.dialog('user', 'selectUser', { title: options.title ?? '', mult: true }, options.signal);
+    }
+    /**
+     * Диалог выбора прав доступа — `BX24.selectAccess()`. `value` — коды,
+     * которые нельзя выбрать. Ожидание — как у `selectUser()`.
+     */
+    selectAccess(options = {}) {
+        return this.dialog('access', 'selectAccess', { value: options.value ?? [] }, options.signal);
+    }
+    /** Диалог выбора объектов CRM — `BX24.selectCRM()`. Ожидание — как у `selectUser()`. */
+    selectCRM(options = {}) {
+        const { entityType, multiple, value, signal } = options;
+        return this.dialog('crm', 'selectCRM', { entityType, multiple, value }, signal);
+    }
+    /**
+     * Открыть приложение в слайдере — `BX24.openApplication()`. Промис
+     * завершается, когда слайдер закрыли. `settings` — настройки слайдера
+     * (уходят как `bx24_<ключ>`, как в BX24.js).
+     */
+    async openApplication(params = {}, settings = {}, options = {}) {
+        const message = { ...params };
+        for (const [key, value] of Object.entries(settings)) {
+            message[`bx24_${key}`] = value;
+        }
+        await this.transport.request('openApplication', message, { timeout: false, signal: options.signal });
+    }
+    /**
+     * Открыть страницу портала в слайдере — `BX24.openPath()`. Промис
+     * завершается, когда слайдер закрыли (`{ result: 'close' }`), или сразу,
+     * если путь не открылся (`{ result: 'error', errorCode }`).
+     */
+    async openPath(path, options = {}) {
+        return await this.transport.request('openPath', { path }, { timeout: false, signal: options.signal });
+    }
+    /**
+     * Закрыть слайдер с приложением — `BX24.closeApplication()`. Если
+     * приложение открыто не в слайдере, ничего не происходит. Узнать о
+     * закрытии может открывший слайдер — через `openApplication()`.
+     */
+    async closeApplication() {
+        this.transport.post('closeApplication', null);
+    }
+    /**
+     * Команда, на которую портал отвечает подтверждением. В некоторых
+     * встраиваниях портал на такие команды не отвечает (так считает и
+     * b24jssdk) — тогда промис завершается с `undefined`, а не ошибкой.
+     */
+    ack(command, params) {
+        return this.transport.request(command, params, { timeout: this.timeout, onTimeout: 'resolve' });
+    }
+    /**
+     * Диалоги ждут пользователя без таймаута. Портал держит один обработчик
+     * на диалог (у выбора сотрудников он общий для `selectUser` и
+     * `selectUsers`) и на прошлый вызов уже не ответит — поэтому новый вызов
+     * отменяет ожидание прошлого.
+     */
+    dialog(kind, command, params, signal) {
+        this.dialogs.get(kind)?.abort();
+        const controller = new AbortController();
+        this.dialogs.set(kind, controller);
+        const onAbort = () => controller.abort();
+        if (signal?.aborted) {
+            controller.abort();
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        return this.transport.request(command, params, { timeout: false, signal: controller.signal })
+            .finally(() => {
+            signal?.removeEventListener('abort', onAbort);
+            if (this.dialogs.get(kind) === controller) {
+                this.dialogs.delete(kind);
+            }
+        });
+    }
+    async getInitData() {
+        const data = asObject('getInitData', await this.transport.request('getInitData', null, { timeout: this.timeout }));
+        // firstRun портал отдаёт только в первом ответе за загрузку страницы —
+        // поэтому запоминаем данные первого ответа, кто бы его ни запросил
+        if (!this.initValue) {
+            this.initValue = this.toInit(data);
+        }
+        return data;
+    }
+    toInit(data) {
+        return {
+            // Как BX24.js: домен — из параметров фрейма, DOMAIN ответа — запасной
+            domain: this.transport.domain || String(data['DOMAIN'] || ''),
+            lang: String(data['LANG'] || ''),
+            path: String(data['PATH'] || ''),
+            https: Number.parseInt(String(data['PROTOCOL']), 10) === 1,
+            memberId: String(data['MEMBER_ID'] || ''),
+            isAdmin: !!data['IS_ADMIN'],
+            install: !!data['INSTALL'],
+            firstRun: !!data['FIRST_RUN'],
+            placement: String(data['PLACEMENT'] || 'DEFAULT'),
+            placementOptions: data['PLACEMENT_OPTIONS'],
+            userOptions: toRecord(data['USER_OPTIONS']),
+            appOptions: toRecord(data['APP_OPTIONS']),
+        };
+    }
+    toAuth(command, data, memberId) {
+        const { AUTH_ID, REFRESH_ID, AUTH_EXPIRES } = data;
+        if (!AUTH_ID || typeof AUTH_ID !== 'string') {
+            throw new BXRestFrameError('NO_AUTH', `Bitrix24 answered ${command} without an access token.`);
+        }
+        // AUTH_EXPIRES — срок жизни токена в секундах. BX24.js переводит его в
+        // момент истечения в миллисекундах — так же, как здесь.
+        const expiresIn = Number.parseInt(String(AUTH_EXPIRES), 10);
+        if (!Number.isFinite(expiresIn) || expiresIn <= 0) {
+            throw new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} without a usable AUTH_EXPIRES.`);
+        }
+        return {
+            access_token: AUTH_ID,
+            refresh_token: typeof REFRESH_ID === 'string' ? REFRESH_ID : '',
+            expires_in: Date.now() + expiresIn * 1000,
+            domain: this.transport.domain,
+            member_id: memberId,
+        };
+    }
+}
+function asObject(command, data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} with a payload that is not an object.`);
+    }
+    return data;
+}
+// Пустые настройки PHP отдаёт массивом `[]`
+function toRecord(value) {
+    return (value && typeof value === 'object' && !Array.isArray(value))
+        ? { ...value }
+        : {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frame.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/services/frame/frame.ts"],"names":[],"mappings":"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","sourcesContent":["import { BXRestFrameError, FrameTransport } from './transport'\nimport {\n  BXRestFrameOptions, iBXRestFrameAccess, iBXRestFrameAuth, iBXRestFrameCrmSelection, iBXRestFrameCrmSelectOptions,\n  iBXRestFrameInit, iBXRestFrameOpenPathResult, iBXRestFramePlacementInfo, iBXRestFramePlacementInterface,\n  iBXRestFrameSize, iBXRestFrameUser,\n} from './types'\n\nconst DEFAULT_TIMEOUT = 10000\n\n/**\n * Команды порталу Bitrix24 из iframe приложения — без подключения BX24.js.\n * Те же команды и те же имена, что у BX24.js, но вместо колбэков —\n * промисы. Протокол внутренний и недокументированный, см. `transport.ts`.\n *\n * Создавайте один экземпляр на страницу и при старте приложения: параметры\n * портала читаются в конструкторе (до того, как роутер перепишет адрес), а\n * `firstRun` портал сообщает только в первом ответе на `getInitData`.\n *\n * Токены класс не логирует и никуда не сохраняет: `getAuth()` и\n * `refreshAuth()` каждый раз спрашивают портал, а в `init()` токенов нет.\n *\n * @example\n * const frame = new BXRestFrame()\n * const { lang, placement } = await frame.init()\n * await frame.fitWindow()\n * const user = await frame.selectUser()\n */\nexport class BXRestFrame {\n\n  private readonly transport = new FrameTransport()\n  private readonly timeout: number\n  private initValue?: iBXRestFrameInit\n  private initRequest?: Promise<iBXRestFrameInit>\n  // Открытый диалог каждого вида — новый вызов того же диалога отменяет прошлый\n  private readonly dialogs = new Map<'user' | 'access' | 'crm', AbortController>()\n\n  /** Мессенджер — как `BX24.im`. Портал на эти команды не отвечает. */\n  readonly im = {\n    /** Позвонить сотруднику — `BX24.im.callTo()`. */\n    callTo: async (userId: number | string, video?: boolean): Promise<void> => {\n      this.transport.post('imCallTo', { userId, video })\n    },\n    /** Позвонить на телефон — `BX24.im.phoneTo()`. */\n    phoneTo: async (phone: string): Promise<void> => {\n      this.transport.post('imPhoneTo', { phone })\n    },\n    /** Открыть чат — `BX24.im.openMessenger()`. */\n    openMessenger: async (dialogId?: number | string): Promise<void> => {\n      this.transport.post('imOpenMessenger', { dialogId })\n    },\n    /** Открыть историю чата — `BX24.im.openHistory()`. */\n    openHistory: async (dialogId: number | string): Promise<void> => {\n      this.transport.post('imOpenHistory', { dialogId })\n    },\n  }\n\n  /** Встраивание — как `BX24.placement`. */\n  readonly placement = {\n    /** Код и параметры встраивания — `BX24.placement.info()`. */\n    info: async (): Promise<iBXRestFramePlacementInfo> => {\n      const { placement, placementOptions } = await this.init()\n      return { placement, options: placementOptions }\n    },\n    /** Команды и события текущего встраивания — `BX24.placement.getInterface()`. */\n    getInterface: async (): Promise<iBXRestFramePlacementInterface> => {\n      return await this.transport.request('getInterface', null, { timeout: this.timeout }) as iBXRestFramePlacementInterface\n    },\n    /**\n     * Команда встраивания — `BX24.placement.call()`. Набор команд зависит от\n     * встраивания (см. `getInterface()`). Не на все команды портал отвечает:\n     * без ответа за `timeout` промис завершается с `undefined`.\n     */\n    call: async (command: string, params?: unknown, options: { timeout?: number | false } = {}): Promise<unknown> => {\n      return this.transport.request(command, params, {\n        timeout: options.timeout ?? this.timeout,\n        onTimeout: 'resolve',\n      })\n    },\n    /**\n     * Подписка на событие встраивания — `BX24.placement.bindEvent()`.\n     * `handler` вызывается при каждом событии. Возвращает функцию отписки:\n     * она только перестаёт вызывать `handler` — отменить подписку на\n     * стороне портала протокол не позволяет. Вне iframe бросает\n     * `BXRestFrameError` с кодом `NOT_IN_FRAME`.\n     */\n    bindEvent: (event: string, handler: (data: unknown) => void): () => void => {\n      return this.transport.subscribe('placementBindEvent', { event }, handler)\n    },\n  }\n\n  /** Настройки приложения для текущего пользователя — как `BX24.userOption`. */\n  readonly userOption = {\n    get: async (name: string): Promise<unknown> => (await this.init()).userOptions[name],\n    set: async (name: string, value: unknown): Promise<void> => {\n      const init = await this.init()\n      init.userOptions[name] = value\n      await this.ack('setUserOption', { name, value })\n    },\n  }\n\n  /** Настройки приложения для всего портала — как `BX24.appOption`. */\n  readonly appOption = {\n    get: async (name: string): Promise<unknown> => (await this.init()).appOptions[name],\n    /**\n     * Менять их может только администратор портала: остальным — ошибка\n     * `ACCESS_DENIED` (BX24.js в этом случае молча ничего не делает).\n     * Возвращает настройки приложения после сохранения.\n     */\n    set: async (name: string, value: unknown): Promise<Record<string, unknown>> => {\n      const init = await this.init()\n      if (!init.isAdmin) {\n        throw new BXRestFrameError('ACCESS_DENIED', 'Only a Bitrix24 administrator can change application options.')\n      }\n      init.appOptions[name] = value\n      return await this.transport.request('setAppOption', { name, value }, { timeout: this.timeout }) as Record<string, unknown>\n    },\n  }\n\n  constructor(options: BXRestFrameOptions = {}) {\n    this.timeout = options.timeout ?? DEFAULT_TIMEOUT\n  }\n\n  /**\n   * Данные запуска приложения — аналог `BX24.init()`: язык, домен, права,\n   * встраивание, настройки, признаки установки. Запрашиваются у портала\n   * один раз, дальше берутся из памяти. Токенов здесь нет — см. `getAuth()`.\n   */\n  init(): Promise<iBXRestFrameInit> {\n    if (this.initValue) {\n      return Promise.resolve(this.initValue)\n    }\n    if (!this.initRequest) {\n      this.initRequest = this.getInitData()\n        .then(() => this.initValue as iBXRestFrameInit)\n        .finally(() => {\n          this.initRequest = undefined\n        })\n    }\n    return this.initRequest\n  }\n\n  /**\n   * Текущая авторизация приложения — аналог `BX24.getAuth()`. Каждый вызов —\n   * новый запрос `getInitData` к порталу.\n   *\n   * `expires_in` портал считает от срока жизни токена в момент выдачи, а не\n   * от остатка: если страница открыта давно, значение будет завышено (так\n   * же и у BX24.js). Для свежего токена используйте `refreshAuth()`.\n   */\n  async getAuth(): Promise<iBXRestFrameAuth> {\n    const data = await this.getInitData()\n    return this.toAuth('getInitData', data, String(data['MEMBER_ID'] || ''))\n  }\n\n  /**\n   * Новая авторизация приложения — аналог `BX24.refreshAuth()`: портал\n   * выпускает новую пару `access_token`/`refresh_token`. Если портал не может\n   * выдать токен, он показывает `alert` «Unable to get new token!» и не\n   * отвечает — тогда ошибка `TIMEOUT`.\n   */\n  async refreshAuth(): Promise<iBXRestFrameAuth> {\n    // member_id приходит только в getInitData — refreshAuth его не возвращает\n    const { memberId } = await this.init()\n    const data = asObject('refreshAuth', await this.transport.request('refreshAuth', {}, { timeout: this.timeout }))\n    return this.toAuth('refreshAuth', data, memberId)\n  }\n\n  /**\n   * Завершить установку — аналог `BX24.installFinish()`: портал отмечает\n   * приложение установленным и перезагружает страницу. Делает что-то только\n   * на странице установщика (`init().install`), иначе — ничего, как и BX24.js.\n   */\n  async installFinish(): Promise<void> {\n    if ((await this.init()).install) {\n      this.transport.post('setInstallFinish', {})\n    }\n  }\n\n  /**\n   * Отметить, что первый запуск у этого пользователя пройден, — то, что\n   * BX24.js делает после последнего обработчика `BX24.install()`. Без этого\n   * `init().firstRun` останется `true` и при следующих запусках. Делает\n   * что-то только при первом запуске.\n   */\n  async firstRunFinish(): Promise<void> {\n    const init = await this.init()\n    if (init.firstRun) {\n      await this.ack('setInstall', { install: true })\n      init.firstRun = false\n    }\n  }\n\n  /** Задать размер фрейма — `BX24.resizeWindow()`. Возвращает размер, который выставил портал. */\n  async resizeWindow(width: number | string, height: number | string): Promise<iBXRestFrameSize | undefined> {\n    const w = Number.parseInt(String(width), 10)\n    const h = Number.parseInt(String(height), 10)\n    if (!(w > 0 && h > 0)) {\n      throw new TypeError('resizeWindow: width and height must be positive numbers.')\n    }\n    return await this.ack('resizeWindow', { width: w, height: h }) as iBXRestFrameSize | undefined\n  }\n\n  /** Подогнать высоту фрейма под содержимое — `BX24.fitWindow()`. */\n  async fitWindow(): Promise<iBXRestFrameSize | undefined> {\n    const root = document.documentElement\n    const height = Math.max(root.scrollHeight, root.offsetHeight)\n    return await this.ack('resizeWindow', { width: '100%', height }) as iBXRestFrameSize | undefined\n  }\n\n  /**\n   * Перезагрузить страницу портала с приложением — `BX24.reloadWindow()`.\n   * Портал на эту команду не отвечает.\n   */\n  async reloadWindow(): Promise<void> {\n    this.transport.post('reloadWindow', {})\n  }\n\n  /** Заголовок страницы портала — `BX24.setTitle()`. */\n  async setTitle(title: string): Promise<{ title: string } | undefined> {\n    return await this.ack('setTitle', { title: String(title) }) as { title: string } | undefined\n  }\n\n  /** Прокрутить страницу портала — `BX24.scrollParentWindow()`. */\n  async scrollParentWindow(scroll: number | string): Promise<{ scroll: number } | undefined> {\n    const value = Number.parseInt(String(scroll), 10)\n    if (Number.isNaN(value)) {\n      throw new TypeError('scrollParentWindow: scroll must be a number.')\n    }\n    return await this.ack('setScroll', { scroll: value }) as { scroll: number } | undefined\n  }\n\n  /**\n   * Диалог выбора одного сотрудника — `BX24.selectUser()`. Ждёт выбора без\n   * ограничения по времени: если пользователь закрыл диалог, портал не\n   * отвечает вовсе. Отменить ожидание — `signal` или новый вызов\n   * `selectUser()`/`selectUsers()` (ошибка `CANCELLED`).\n   */\n  selectUser(options: { title?: string, signal?: AbortSignal } = {}): Promise<iBXRestFrameUser> {\n    return this.dialog('user', 'selectUser', { title: options.title ?? '', mult: false }, options.signal) as Promise<iBXRestFrameUser>\n  }\n\n  /** Диалог выбора нескольких сотрудников — `BX24.selectUsers()`. Ожидание — как у `selectUser()`. */\n  selectUsers(options: { title?: string, signal?: AbortSignal } = {}): Promise<iBXRestFrameUser[]> {\n    return this.dialog('user', 'selectUser', { title: options.title ?? '', mult: true }, options.signal) as Promise<iBXRestFrameUser[]>\n  }\n\n  /**\n   * Диалог выбора прав доступа — `BX24.selectAccess()`. `value` — коды,\n   * которые нельзя выбрать. Ожидание — как у `selectUser()`.\n   */\n  selectAccess(options: { value?: string[], signal?: AbortSignal } = {}): Promise<iBXRestFrameAccess[]> {\n    return this.dialog('access', 'selectAccess', { value: options.value ?? [] }, options.signal) as Promise<iBXRestFrameAccess[]>\n  }\n\n  /** Диалог выбора объектов CRM — `BX24.selectCRM()`. Ожидание — как у `selectUser()`. */\n  selectCRM(options: iBXRestFrameCrmSelectOptions = {}): Promise<iBXRestFrameCrmSelection> {\n    const { entityType, multiple, value, signal } = options\n    return this.dialog('crm', 'selectCRM', { entityType, multiple, value }, signal) as Promise<iBXRestFrameCrmSelection>\n  }\n\n  /**\n   * Открыть приложение в слайдере — `BX24.openApplication()`. Промис\n   * завершается, когда слайдер закрыли. `settings` — настройки слайдера\n   * (уходят как `bx24_<ключ>`, как в BX24.js).\n   */\n  async openApplication(\n    params: Record<string, unknown> = {},\n    settings: Record<string, unknown> = {},\n    options: { signal?: AbortSignal } = {}\n  ): Promise<void> {\n    const message: Record<string, unknown> = { ...params }\n    for (const [key, value] of Object.entries(settings)) {\n      message[`bx24_${key}`] = value\n    }\n    await this.transport.request('openApplication', message, { timeout: false, signal: options.signal })\n  }\n\n  /**\n   * Открыть страницу портала в слайдере — `BX24.openPath()`. Промис\n   * завершается, когда слайдер закрыли (`{ result: 'close' }`), или сразу,\n   * если путь не открылся (`{ result: 'error', errorCode }`).\n   */\n  async openPath(path: string, options: { signal?: AbortSignal } = {}): Promise<iBXRestFrameOpenPathResult> {\n    return await this.transport.request('openPath', { path }, { timeout: false, signal: options.signal }) as iBXRestFrameOpenPathResult\n  }\n\n  /**\n   * Закрыть слайдер с приложением — `BX24.closeApplication()`. Если\n   * приложение открыто не в слайдере, ничего не происходит. Узнать о\n   * закрытии может открывший слайдер — через `openApplication()`.\n   */\n  async closeApplication(): Promise<void> {\n    this.transport.post('closeApplication', null)\n  }\n\n  /**\n   * Команда, на которую портал отвечает подтверждением. В некоторых\n   * встраиваниях портал на такие команды не отвечает (так считает и\n   * b24jssdk) — тогда промис завершается с `undefined`, а не ошибкой.\n   */\n  private ack(command: string, params: unknown): Promise<unknown> {\n    return this.transport.request(command, params, { timeout: this.timeout, onTimeout: 'resolve' })\n  }\n\n  /**\n   * Диалоги ждут пользователя без таймаута. Портал держит один обработчик\n   * на диалог (у выбора сотрудников он общий для `selectUser` и\n   * `selectUsers`) и на прошлый вызов уже не ответит — поэтому новый вызов\n   * отменяет ожидание прошлого.\n   */\n  private dialog(kind: 'user' | 'access' | 'crm', command: string, params: unknown, signal?: AbortSignal): Promise<unknown> {\n    this.dialogs.get(kind)?.abort()\n    const controller = new AbortController()\n    this.dialogs.set(kind, controller)\n\n    const onAbort = () => controller.abort()\n    if (signal?.aborted) {\n      controller.abort()\n    }\n    signal?.addEventListener('abort', onAbort, { once: true })\n\n    return this.transport.request(command, params, { timeout: false, signal: controller.signal })\n      .finally(() => {\n        signal?.removeEventListener('abort', onAbort)\n        if (this.dialogs.get(kind) === controller) {\n          this.dialogs.delete(kind)\n        }\n      })\n  }\n\n  private async getInitData(): Promise<Record<string, unknown>> {\n    const data = asObject('getInitData', await this.transport.request('getInitData', null, { timeout: this.timeout }))\n    // firstRun портал отдаёт только в первом ответе за загрузку страницы —\n    // поэтому запоминаем данные первого ответа, кто бы его ни запросил\n    if (!this.initValue) {\n      this.initValue = this.toInit(data)\n    }\n    return data\n  }\n\n  private toInit(data: Record<string, unknown>): iBXRestFrameInit {\n    return {\n      // Как BX24.js: домен — из параметров фрейма, DOMAIN ответа — запасной\n      domain: this.transport.domain || String(data['DOMAIN'] || ''),\n      lang: String(data['LANG'] || ''),\n      path: String(data['PATH'] || ''),\n      https: Number.parseInt(String(data['PROTOCOL']), 10) === 1,\n      memberId: String(data['MEMBER_ID'] || ''),\n      isAdmin: !!data['IS_ADMIN'],\n      install: !!data['INSTALL'],\n      firstRun: !!data['FIRST_RUN'],\n      placement: String(data['PLACEMENT'] || 'DEFAULT'),\n      placementOptions: data['PLACEMENT_OPTIONS'],\n      userOptions: toRecord(data['USER_OPTIONS']),\n      appOptions: toRecord(data['APP_OPTIONS']),\n    }\n  }\n\n  private toAuth(command: string, data: Record<string, unknown>, memberId: string): iBXRestFrameAuth {\n    const { AUTH_ID, REFRESH_ID, AUTH_EXPIRES } = data\n    if (!AUTH_ID || typeof AUTH_ID !== 'string') {\n      throw new BXRestFrameError('NO_AUTH', `Bitrix24 answered ${command} without an access token.`)\n    }\n    // AUTH_EXPIRES — срок жизни токена в секундах. BX24.js переводит его в\n    // момент истечения в миллисекундах — так же, как здесь.\n    const expiresIn = Number.parseInt(String(AUTH_EXPIRES), 10)\n    if (!Number.isFinite(expiresIn) || expiresIn <= 0) {\n      throw new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} without a usable AUTH_EXPIRES.`)\n    }\n    return {\n      access_token: AUTH_ID,\n      refresh_token: typeof REFRESH_ID === 'string' ? REFRESH_ID : '',\n      expires_in: Date.now() + expiresIn * 1000,\n      domain: this.transport.domain,\n      member_id: memberId,\n    }\n  }\n}\n\nfunction asObject(command: string, data: unknown): Record<string, unknown> {\n  if (!data || typeof data !== 'object' || Array.isArray(data)) {\n    throw new BXRestFrameError('BAD_RESPONSE', `Bitrix24 answered ${command} with a payload that is not an object.`)\n  }\n  return data as Record<string, unknown>\n}\n\n// Пустые настройки PHP отдаёт массивом `[]`\nfunction toRecord(value: unknown): Record<string, unknown> {\n  return (value && typeof value === 'object' && !Array.isArray(value))\n    ? { ...value as Record<string, unknown> }\n    : {}\n}\n"]}