intelicoreact 2.0.5 → 2.0.6

package/dist/Atomic/FormElements/CheckboxInput/CheckboxInput.interface.d.ts

@@ -1,7 +1,8 @@
 import type React from 'react';
+import type { ReactNode } from 'react';
 import type { IUniProps } from '../../../types/base.interface';
 export interface ICheckboxInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'id'>, IUniProps {
-    label: string;
+    label: string | ReactNode;
     id?: string | number;
     value?: boolean;
     onChange?: (value: boolean, event: React.ChangeEvent<HTMLInputElement>) => void;

package/dist/Atomic/FormElements/FileLoaderDescription/FileLoaderDescription.interface.d.ts

@@ -1,9 +1,9 @@
 export interface IFile {
     id?: string | number;
     value: string;
-    base64: string;
-    maxItemSizeBytes: number;
-    error: string | null;
+    base64?: string;
+    maxItemSizeBytes?: number;
+    error?: string | null;
     outerError?: string | null | boolean;
     isRequired?: boolean;
     accept?: string;

package/dist/Atomic/FormElements/Switcher/Switcher.interface.d.ts

@@ -1,10 +1,11 @@
 import type React from 'react';
+import type { ReactNode } from 'react';
 import type { IUniProps } from '../../../types/base.interface';
 export interface ISwitcherProps extends IUniProps {
     isLabelBold?: boolean;
     disabled?: boolean;
     isIncludeOuterStyles?: boolean;
-    label?: string;
+    label?: string | ReactNode;
     className?: string;
     isActive?: boolean;
     hint?: React.ReactNode;

package/dist/Atomic/UI/AccordionText/AccordionText.interface.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+/**
+ * Props компонента `<AccordionText>`. Раньше тип default-export получал
+ * TS-inference из `.js`, что давало `text: string` (потерявшийся ReactNode).
+ * Этот interface восстанавливает type-safe usage с поддержкой JSX в `text`.
+ */
+export interface IAccordionTextProps {
+    isDefaultOpen?: boolean;
+    isOuterOpen?: boolean;
+    className?: string;
+    text?: string | ReactNode;
+    shortText?: string | ReactNode | null;
+}

package/dist/Atomic/UI/Alert/Alert.interface.d.ts

@@ -2,7 +2,7 @@ import type { CSSProperties, ReactNode } from 'react';
 import type { IUniProps } from '../../../types/base.interface';
 type TButtonVariant = 'primary' | 'ellipse-apply' | 'ellipse-cancel' | string;
 export interface IAlertProps extends IUniProps {
-    message?: string;
+    message?: string | ReactNode;
     icon?: ReactNode;
     iconDynamicKey?: string;
     iconDynamicProps?: Record<string, any>;

package/dist/Functions/sdk/runtime-sdk/client.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeClient, RuntimeClientConfig } from './types';
+/**
+ * Создаёт и возвращает singleton-инстанс клиента для работы с
+ * runtime-эндпоинтами MCP Contract Intelligence сервера.
+ *
+ * Вызывается один раз при инициализации фронта. Полученный инстанс
+ * используется во всём приложении для отправки runtime-логов (REST/WS)
+ * и удаления накопленных логов на сервере.
+ *
+ * Внутри:
+ *  - нормализует конфиг и выставляет оптимизированные дефолты
+ *  - поднимает внутреннюю очередь-батчер (interval + size triggers)
+ *  - регистрирует `pagehide` / `beforeunload` listener'ы для
+ *    отправки последнего батча через `navigator.sendBeacon`
+ *
+ * SDK не бросает ошибки наружу при проблемах сети/лимитов —
+ * всё уходит в `logger` и `onError`, чтобы не ронять прод.
+ */
+export declare function createRuntimeClient(rawConfig: RuntimeClientConfig): RuntimeClient;

package/dist/Functions/sdk/runtime-sdk/config.d.ts

@@ -0,0 +1,32 @@
+import type { ResolvedConfig, RuntimeClientConfig } from './types';
+/**
+ * Нормализует пользовательский конфиг в `ResolvedConfig` со всеми
+ * дефолтами и валидацией.
+ *
+ * Что делает:
+ *  - проверяет обязательные поля (`baseUrl`)
+ *  - обрезает хвостовые слэши у `baseUrl`
+ *  - подставляет `fetch` из глобалов или из `config.fetchImpl`
+ *    (нужен для SSR/Node-тестов, где `globalThis.fetch` может отсутствовать)
+ *  - применяет оптимизированные дефолты и clamp на разумные границы,
+ *    чтобы кривые значения (0, Infinity, отрицательные) не ломали SDK
+ *  - выбирает logger: явный → передан, иначе console-логгер в debug,
+ *    иначе no-op
+ *
+ * Бросает `Error` только при фатально неправильной конфигурации.
+ */
+export declare function resolveConfig(config: RuntimeClientConfig): ResolvedConfig;
+/**
+ * Собирает финальный набор HTTP-заголовков для запроса.
+ *
+ * Приоритет (поздний перезатирает ранний):
+ *  1. `Content-Type: application/json` по умолчанию
+ *  2. `config.headers` из конфига SDK
+ *  3. `extra` — точечные заголовки конкретного запроса
+ *  4. `X-API-Key` из `config.apiKey`, если задан — всегда поверх всего,
+ *     чтобы его нельзя было случайно переопределить через `headers`
+ *
+ * Сервер использует `X-API-Key` как bucket-key для rate-limiter'а
+ * (см. `ingestion-rate-limit.guard.ts`). Это **не** токен авторизации.
+ */
+export declare function buildHeaders(config: ResolvedConfig, extra?: Record<string, string>): Record<string, string>;

package/dist/Functions/sdk/runtime-sdk/index.d.ts

@@ -0,0 +1,3 @@
+export { createRuntimeClient } from './client';
+export { HttpError } from './transport';
+export type { BatchIngestRequest, BatchIngestResponse, DeleteLogsFilter, DeleteLogsResponse, Logger, RestRuntimeLog, RuntimeClient, RuntimeClientConfig, RuntimeLog, WsRuntimeLog, } from './types';

package/dist/Functions/sdk/runtime-sdk/queue.d.ts

@@ -0,0 +1,70 @@
+import type { ResolvedConfig, RuntimeLog } from './types';
+export declare class BatchQueue {
+    private readonly config;
+    private buffer;
+    private timer;
+    private inflight;
+    private destroyed;
+    /**
+     * Создаёт очередь и, если `flushIntervalMs > 0`, запускает
+     * периодический таймер флаша. Таймер будет тикать до тех пор,
+     * пока не вызовут `destroy()`.
+     */
+    constructor(config: ResolvedConfig);
+    /**
+     * Текущее количество событий в буфере (ещё не отправленных).
+     * Полезно для метрик/дебага.
+     */
+    size(): number;
+    /**
+     * Добавить события в буфер.
+     *
+     * Триггеры автоматического флаша:
+     *  - буфер достиг `batchSize` → сразу уходит HTTP-запрос
+     *  - буфер превысил `maxQueueSize` → лишние **старые** события
+     *    дропаются (FIFO), чтобы не раздувать память при сбое сети
+     *
+     * После `destroy()` вызов игнорируется.
+     */
+    enqueue(logs: RuntimeLog[]): void;
+    /**
+     * Забрать всё из буфера и отправить одним батчем в
+     * `POST /api/runtime/ingest`.
+     *
+     * Если уже есть активный in-flight запрос — возвращаем его же
+     * промис (защита от параллельных флашей по таймеру и по размеру).
+     *
+     * Ошибки HTTP/сети сюда не всплывают — они проглатываются
+     * после всех retry-попыток и логируются как 'error'. Дроп
+     * целого батча при окончательном фейле — осознанный компромисс:
+     * лучше потерять часть телеметрии, чем заблокировать очередь.
+     */
+    flush(): Promise<void>;
+    /**
+     * Отправить буфер через `navigator.sendBeacon` при закрытии вкладки.
+     *
+     * В отличие от обычного `flush()`:
+     *  - fire-and-forget: нет ответа и нет retry
+     *  - браузер гарантирует доставку даже после того как страница
+     *    уже уничтожается (unload / pagehide)
+     *  - нет заголовка `X-API-Key` (sendBeacon не даёт менять headers,
+     *    но `Content-Type` нам выставляет сам тип Blob)
+     *
+     * Возвращает `true` если браузер принял пачку в свою очередь,
+     * `false` при отсутствии API или отказе (например слишком
+     * большой payload — лимит обычно 64 КБ).
+     */
+    flushBeacon(): boolean;
+    /**
+     * Остановить очередь и освободить ресурсы.
+     *
+     * Чистит таймер флаша, обнуляет буфер, помечает инстанс
+     * уничтоженным — последующие `enqueue`/`flush`/`flushBeacon`
+     * становятся no-op. Идемпотентна.
+     *
+     * Важно: in-flight запрос, если он был запущен до `destroy`,
+     * не отменяется — он либо завершится штатно, либо по таймауту
+     * `requestTimeoutMs`.
+     */
+    destroy(): void;
+}

package/dist/Functions/sdk/runtime-sdk/transport.d.ts

@@ -0,0 +1,41 @@
+import type { ResolvedConfig } from './types';
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly body: string;
+    readonly retryAfterMs?: number | undefined;
+    constructor(status: number, body: string, retryAfterMs?: number | undefined);
+}
+interface RequestOptions {
+    method: 'POST' | 'DELETE' | 'GET';
+    path: string;
+    body?: unknown;
+    query?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * Однократный HTTP-запрос без retry-логики.
+ *
+ * Особенности:
+ *  - таймаут через `AbortController`, дефолт 8 с
+ *  - non-2xx ответ → `HttpError` с распарсенным `Retry-After`
+ *  - поддерживает `application/json` и text-ответы
+ *  - 204 No Content → резолв `undefined`
+ *
+ * Используется как строительный блок для `requestWithRetry`
+ * и для случаев, где retry не нужен (напр. программная отмена).
+ */
+export declare function request<T>(config: ResolvedConfig, options: RequestOptions): Promise<T>;
+/**
+ * HTTP-запрос с экспоненциальным бэкоффом и уважением к `Retry-After`.
+ *
+ * Retry-стратегия:
+ *  - 429 Too Many Requests → ждём `Retry-After` (секунды или HTTP-date)
+ *  - 5xx → экспоненциальный бэкофф `300 * 2^attempt + jitter`, cap 10 с
+ *  - `AbortError` / `TypeError` (сетевые) → тоже retry
+ *  - 4xx кроме 429 → сразу финальный reject (чинить нечего)
+ *
+ * Каждая попытка (успех или нет) проходит через `logger` и `onError`
+ * с указанием `phase` — это даёт наблюдаемость без перехвата промиса.
+ */
+export declare function requestWithRetry<T>(config: ResolvedConfig, options: RequestOptions, phase: 'ingest' | 'delete'): Promise<T>;
+export {};

package/dist/Functions/sdk/runtime-sdk/types.d.ts

@@ -0,0 +1,84 @@
+export interface RuntimeLogBase {
+    service: string;
+    status?: number;
+    response?: unknown;
+    payload?: unknown;
+    timestamp?: string;
+}
+export interface RestRuntimeLog extends RuntimeLogBase {
+    type: 'rest';
+    path: string;
+    method: string;
+}
+export interface WsRuntimeLog extends RuntimeLogBase {
+    type: 'ws';
+    event: string;
+}
+export type RuntimeLog = RestRuntimeLog | WsRuntimeLog;
+export interface BatchIngestRequest {
+    logs: RuntimeLog[];
+}
+export interface BatchIngestResponse {
+    accepted: number;
+}
+export type DeleteLogsFilter = {
+    service: string;
+    type: 'rest';
+    path: string;
+    method: string;
+} | {
+    service: string;
+    type: 'ws';
+    event: string;
+};
+export interface DeleteLogsResponse {
+    deleted: number;
+}
+export type Logger = (level: 'debug' | 'warn' | 'error', message: string, meta?: unknown) => void;
+export interface RuntimeClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    enabled?: boolean;
+    debug?: boolean;
+    batchSize?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    maxRetries?: number;
+    requestTimeoutMs?: number;
+    flushOnUnload?: boolean;
+    fetchImpl?: typeof fetch;
+    logger?: Logger;
+    onError?: (error: unknown, context: {
+        phase: 'ingest' | 'delete';
+        attempt: number;
+    }) => void;
+    headers?: Record<string, string>;
+}
+export interface ResolvedConfig {
+    baseUrl: string;
+    apiKey?: string;
+    enabled: boolean;
+    debug: boolean;
+    batchSize: number;
+    flushIntervalMs: number;
+    maxQueueSize: number;
+    maxRetries: number;
+    requestTimeoutMs: number;
+    flushOnUnload: boolean;
+    fetchImpl: typeof fetch;
+    logger: Logger;
+    onError?: (error: unknown, context: {
+        phase: 'ingest' | 'delete';
+        attempt: number;
+    }) => void;
+    headers: Record<string, string>;
+}
+export interface RuntimeClient {
+    track: (log: RuntimeLog) => void;
+    trackMany: (logs: RuntimeLog[]) => void;
+    flush: () => Promise<void>;
+    deleteLogs: (filter: DeleteLogsFilter) => Promise<DeleteLogsResponse>;
+    isEnabled: () => boolean;
+    setEnabled: (enabled: boolean) => void;
+    destroy: () => void;
+}

package/dist/Molecular/FormElement/FormElement.interface.d.ts

@@ -19,7 +19,7 @@ export interface IFormElementProps extends IUniProps {
     placeholder?: string;
     mask?: string;
     alert?: {
-        message: string;
+        message: string | ReactNode;
         variant: 'info' | 'warning' | 'error' | 'success';
         noDismiss?: boolean;
     };

package/dist/Molecular/FormWithDependOn/FormWithDependOn.interface.d.ts

@@ -0,0 +1,99 @@
+import type { ReactElement, ReactNode, Ref } from 'react';
+/**
+ * Минимальная форма-поле, которое FormWithDependOn ожидает в массиве `form`.
+ * Реальные поля имеют больше свойств (зависят от типа), но эти три обязательны
+ * для работы dependOn-механики.
+ */
+export interface IFormWithDependOnField {
+    key: string;
+    value?: unknown;
+    dependOn?: unknown;
+    [extra: string]: unknown;
+}
+/**
+ * Аргумент `additionalOfOnChange` — необязательный объект с метаданными,
+ * который верхний onChange может пробросить вниз через DependOn-механику.
+ */
+export interface IFormWithDependOnAdditional {
+    updatedForm?: IFormWithDependOnField[];
+    isMakeChangesAnyway?: boolean;
+    isUseActualForm?: boolean;
+    [extra: string]: unknown;
+}
+/**
+ * Контекст, передаваемый в `getAnotherActions`. Содержит вспомогательные
+ * функции, которые можно вызывать из middleware-экшенов.
+ */
+export interface IFormWithDependOnActionsContext<TField extends IFormWithDependOnField = IFormWithDependOnField> {
+    setForm: (form: TField[]) => void;
+    assign: (changes: Partial<TField>, fieldKey: string) => void;
+    getActualForm: () => TField[];
+}
+/**
+ * Сигнатура одного экшена в map'е, возвращаемом `getAnotherActions`.
+ * Может быть `all` (срабатывает на любое изменение) или `<fieldKey>`
+ * (только при изменении конкретного поля). Возвращаемое значение —
+ * частичные изменения, которые будут применены через `assign`.
+ */
+export type FormWithDependOnAction<TField extends IFormWithDependOnField = IFormWithDependOnField> = (params: {
+    newValue: unknown;
+    fieldKey: string;
+    propKey: string | undefined;
+    field: TField;
+    form: TField[];
+    additional: Record<string, unknown>;
+}) => Partial<TField> | void;
+export type FormWithDependOnActionsMap<TField extends IFormWithDependOnField = IFormWithDependOnField> = {
+    all?: FormWithDependOnAction<TField>;
+    [fieldKey: string]: FormWithDependOnAction<TField> | undefined;
+};
+/**
+ * Props компонента `<FormWithDependOn>`. Generic-параметр `TField` позволяет
+ * вызывающему коду указать конкретный shape поля и получить type-safe
+ * `onChange`, `renderField`, `getAnotherActions`.
+ *
+ * @example
+ * ```tsx
+ * type MyField = IFormWithDependOnField & { type: 'text' | 'select' };
+ * <FormWithDependOn<MyField>
+ *   form={fields}
+ *   setForm={setFields}
+ *   onChange={(value, key) => ...}
+ *   renderField={(field) => <Input ... />}
+ * />
+ * ```
+ */
+export interface IFormWithDependOnProps<TField extends IFormWithDependOnField = IFormWithDependOnField> {
+    form: TField[];
+    setForm: (form: TField[]) => void;
+    formId?: string;
+    /**
+     * Опциональный геттер актуальной формы (для асинхронных последовательных
+     * зависимостей). По умолчанию вернёт текущий `form` prop.
+     *
+     * @deprecated рекомендуется НЕ использовать — работает плохо в текущей
+     * реализации (см. JS-source TODO от автора либы).
+     */
+    getActualForm?: () => TField[];
+    /** Главный обработчик изменения значения поля. */
+    onChange?: (newValue: unknown, fieldKey: string, propKey?: string, additionalOfOnChange?: IFormWithDependOnAdditional) => void;
+    /** Рендер одного поля. Receives field + bound onChange. */
+    renderField?: (field: TField, index: number) => ReactNode;
+    /**
+     * Фабрика map'а side-actions. Срабатывают после dependOn-обработки.
+     * Возвращаемые changes применяются через `assign`.
+     */
+    getAnotherActions?: (ctx: IFormWithDependOnActionsContext<TField>) => FormWithDependOnActionsMap<TField>;
+    className?: string;
+    isInitializeByDependOn?: boolean;
+    isFormDisabled?: boolean;
+    typeOfUse?: 'default' | string;
+}
+/**
+ * Тип default-export компонента `FormWithDependOn`. Раньше тип default-export
+ * получал TS-inference из `.js` source'а и терял generic. Этот declaration
+ * восстанавливает generic для type-safe usage.
+ */
+export type FormWithDependOnComponent = <TField extends IFormWithDependOnField = IFormWithDependOnField>(props: IFormWithDependOnProps<TField> & {
+    ref?: Ref<unknown>;
+}) => ReactElement | null;

package/dist/classes.cjs

@@ -91,12 +91,14 @@ var AbortableFetch = class {
           response.request = item;
           return response;
         }).catch(
-          (response) => Promise.resolve({
-            ok: false,
-            status: 0,
-            statusText: response,
-            request: item
-          })
+          (response) => {
+            return Promise.resolve({
+              ok: false,
+              status: 0,
+              statusText: response,
+              request: item
+            });
+          }
         );
         if (this.#everyPromiseCallback && !item.isSkipEveryPromiseCallback)
           request = request.then(
@@ -470,7 +472,7 @@ var AbortableFetch2 = class {
     const abortController = new AbortController();
     const addProps = (response, request) => {
       response.request = request;
-      if (ABORTABLE_FETCH_CONTEXT.#isResponseAsObject) response.name = request.name;
+      if (ABORTABLE_FETCH_CONTEXT.#isResponseAsObject) response.name = getIsOnlyAnObject(request) ? request.name || "" : "";
       return response;
     };
     let externalRequest = Promise.all(
@@ -792,7 +794,7 @@ async function getInstanceOfFetchSystem(isGetBody) {
       everyPromiseCallback: async function everyPromiseCallback(response) {
         const ABORTABLE_FETCH_INSTANCE = this;
         if (!response.status) {
-          const request = ABORTABLE_FETCH_INSTANCE.requestInput.find((item) => item.path === response.request.path);
+          const request = ABORTABLE_FETCH_INSTANCE.requestInput.find((item) => item?.path === response?.request?.path);
           const isUseErrorToast = request?.mesageOptions?.isUseErrorToast;
           if (isUseErrorToast) {
             API_CONTEXT.sendMessage?.(API_CONTEXT.NO_INET, request.mesageOptions, response);