synapse-storage 3.0.19 → 4.0.1

package/dist/reactive/dispatcher/standalone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/dispatcher/standalone.js","sources":["../../../src/reactive/dispatcher/standalone.ts"],"sourcesContent":["import type { IStorage } from '../../core'\n\n// ────────────────────────────────────────────────────────────────────────────\n// Types\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * Параметры исполнения действия (мемоизация)\n */\nexport interface ActionExecutionOptions<TParams, TResult> {\n  memoize?: (currentArgs: TParams, previousArgs: TParams, previousResult: TResult) => boolean\n}\n\n/**\n * Рецепт действия — standalone-определение, не привязанное к хранилищу.\n * Привязывается к storage при регистрации в createDispatcher.\n */\nexport interface ActionRecipe<TState extends Record<string, any>, TParams, TResult> {\n  readonly _type: 'action-recipe'\n  readonly _config: {\n    action: (storage: IStorage<TState>, params: TParams) => Promise<TResult> | TResult\n    meta?: Record<string, any>\n  }\n  readonly _executionOptions?: ActionExecutionOptions<TParams, TResult>\n}\n\n/**\n * Рецепт watcher'а — standalone-определение, не привязанное к хранилищу.\n */\nexport interface WatcherRecipe<TState extends Record<string, any>, R> {\n  readonly _type: 'watcher-recipe'\n  readonly _config: {\n    selector: (state: TState) => R\n    meta?: Record<string, any>\n    shouldTrigger?: (prev: R | undefined, current: R) => boolean\n    notifyAfterSubscribe?: boolean\n  }\n}\n\n/**\n * Состояние API-запроса для createApiActions\n */\nexport interface ApiRequestState {\n  status: 'idle' | 'loading' | 'success' | 'error' | 'reset'\n  error: string | null\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// defineAction\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * Создаёт standalone-определение действия.\n * Фиксирует TState через первый вызов, TParams/TResult инферятся из action.\n *\n * @example\n * ```ts\n * const action = defineAction<MyState>()\n *\n * export const increment = action({\n *   action: (storage, amount: number) => {\n *     storage.update((s) => { s.count += amount })\n *     return amount\n *   },\n * })\n *\n * // Void action (без параметров и возврата):\n * export const reset = action({\n *   action: (storage) => {\n *     storage.update((s) => { s.count = 0 })\n *   },\n * })\n * ```\n */\nexport function defineAction<TState extends Record<string, any>>() {\n  return <TParams = void, TResult = void>(\n    config: {\n      action: (storage: IStorage<TState>, params: TParams) => Promise<TResult> | TResult\n      meta?: Record<string, any>\n    },\n    executionOptions?: ActionExecutionOptions<TParams, TResult>,\n  ): ActionRecipe<TState, TParams, TResult> => ({\n    _type: 'action-recipe' as const,\n    _config: config,\n    _executionOptions: executionOptions,\n  })\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// defineWatcher\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * Создаёт standalone-определение watcher'а.\n *\n * @example\n * ```ts\n * export const watchCount = defineWatcher<MyState>()({\n *   selector: (s) => s.items.length,\n *   notifyAfterSubscribe: true,\n * })\n * ```\n */\nexport function defineWatcher<TState extends Record<string, any>>() {\n  return <R>(config: {\n    selector: (state: TState) => R\n    meta?: Record<string, any>\n    shouldTrigger?: (prev: R | undefined, current: R) => boolean\n    notifyAfterSubscribe?: boolean\n  }): WatcherRecipe<TState, R> => ({\n    _type: 'watcher-recipe' as const,\n    _config: config,\n  })\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// createApiActions\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * Вычисляет путь к свойству через Proxy-перехват обращений.\n */\nfunction resolvePath<T>(accessor: (draft: T) => any): string[] {\n  const path: string[] = []\n  const handler: ProxyHandler<any> = {\n    get(_, prop) {\n      if (typeof prop === 'string') {\n        path.push(prop)\n      }\n      return new Proxy({}, handler)\n    },\n  }\n  accessor(new Proxy({}, handler) as T)\n  return path\n}\n\n/**\n * Записывает значение по пути в объекте.\n */\nfunction setByPath(obj: any, path: string[], value: any): void {\n  let current = obj\n  for (let i = 0; i < path.length - 1; i++) {\n    current = current[path[i]]\n  }\n  current[path[path.length - 1]] = value\n}\n\n/**\n * Создаёт набор шаблонных lifecycle-действий для API-запроса.\n * Accessor указывает на поле ApiRequestState в стейте — путь вычисляется автоматически.\n *\n * @param accessor - Функция-accessor, указывающая на поле ApiRequestState в стейте\n *\n * @example\n * ```ts\n * const listRequest = createApiActions<MyState>(\n *   (draft) => draft.api.listRequest\n * )\n *\n * // В dispatcher:\n * createDispatcher({ storage }, {\n *   loadListInit:    listRequest.init,\n *   loadListLoading: listRequest.loading,\n *   loadListSuccess: listRequest.success,\n *   loadListFailure: listRequest.failure,\n *   loadListReset:   listRequest.reset,\n * })\n * ```\n */\nexport function createApiActions<TState extends Record<string, any>>(accessor: (draft: TState) => ApiRequestState) {\n  const path = resolvePath(accessor)\n  const action = defineAction<TState>()\n\n  const update = (storage: IStorage<TState>, request: ApiRequestState) => {\n    storage.update((s) => setByPath(s, path, request))\n  }\n\n  return {\n    init: action({\n      action: (storage) => update(storage, { status: 'idle', error: null }),\n    }),\n\n    loading: action({\n      action: (storage) => update(storage, { status: 'loading', error: null }),\n    }),\n\n    success: action({\n      action: (storage) => update(storage, { status: 'success', error: null }),\n    }),\n\n    failure: action({\n      action: (storage, error: string) => update(storage, { status: 'error', error }),\n    }),\n\n    reset: action({\n      action: (storage) => update(storage, { status: 'reset', error: null }),\n    }),\n  }\n}\n"],"names":["defineAction","config","executionOptions","defineWatcher","resolvePath","accessor","path","handler","_","prop","Proxy","setByPath","obj","value","current","i","createApiActions","action","update","storage","request","s","error"],"mappings":"AA+CA,+EAA+E;AAC/E,eAAe;AACf,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACM,SAASA,YAAYA;IAC1B,OAAO,CACLC,QAIAC,mBAC4C;YAC5C,OAAO;YACP,SAASD;YACT,mBAAmBC;QACrB;AACF;AAEA,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E;;;;;;;;;;CAUC,GACM,SAASC,aAAaA;IAC3B,OAAO,CAAIF,SAKsB;YAC/B,OAAO;YACP,SAASA;QACX;AACF;AAEA,+EAA+E;AAC/E,mBAAmB;AACnB,+EAA+E;AAE/E;;CAEC,GACD,SAASG,WAAWA,CAAIC,QAA2B;IACjD,MAAMC,OAAiB,EAAE;IACzB,MAAMC,UAA6B;QACjC,KAAIC,CAAC,EAAEC,IAAI;YACT,IAAI,OAAOA,SAAS,UAAU;gBAC5BH,KAAK,IAAI,CAACG;YACZ;YACA,OAAO,IAAIC,MAAM,CAAC,GAAGH;QACvB;IACF;IACAF,SAAS,IAAIK,MAAM,CAAC,GAAGH;IACvB,OAAOD;AACT;AAEA;;CAEC,GACD,SAASK,SAASA,CAACC,GAAQ,EAAEN,IAAc,EAAEO,KAAU;IACrD,IAAIC,UAAUF;IACd,IAAK,IAAIG,IAAI,GAAGA,IAAIT,KAAK,MAAM,GAAG,GAAGS,IAAK;QACxCD,UAAUA,OAAO,CAACR,IAAI,CAACS,EAAE,CAAC;IAC5B;IACAD,OAAO,CAACR,IAAI,CAACA,KAAK,MAAM,GAAG,EAAE,CAAC,GAAGO;AACnC;AAEA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACM,SAASG,gBAAgBA,CAAqCX,QAA4C;IAC/G,MAAMC,OAAOF,WAAWA,CAACC;IACzB,MAAMY,SAASjB,YAAYA;IAE3B,MAAMkB,SAAS,CAACC,SAA2BC;QACzCD,QAAQ,MAAM,CAAC,CAACE,IAAMV,SAASA,CAACU,GAAGf,MAAMc;IAC3C;IAEA,OAAO;QACL,MAAMH,OAAO;YACX,QAAQ,CAACE,UAAYD,OAAOC,SAAS;oBAAE,QAAQ;oBAAQ,OAAO;gBAAK;QACrE;QAEA,SAASF,OAAO;YACd,QAAQ,CAACE,UAAYD,OAAOC,SAAS;oBAAE,QAAQ;oBAAW,OAAO;gBAAK;QACxE;QAEA,SAASF,OAAO;YACd,QAAQ,CAACE,UAAYD,OAAOC,SAAS;oBAAE,QAAQ;oBAAW,OAAO;gBAAK;QACxE;QAEA,SAASF,OAAO;YACd,QAAQ,CAACE,SAASG,QAAkBJ,OAAOC,SAAS;oBAAE,QAAQ;oBAASG;gBAAM;QAC/E;QAEA,OAAOL,OAAO;YACZ,QAAQ,CAACE,UAAYD,OAAOC,SAAS;oBAAE,QAAQ;oBAAS,OAAO;gBAAK;QACtE;IACF;AACF"}

package/dist/reactive/effects/effects.module.d.ts

@@ -0,0 +1,225 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { IStorage, IStorageBase } from '../../core';
+import { Action, ActionsResult, Dispatcher, DispatchFunction, ExtractResultType, WatcherFunction } from '../dispatcher';
+import { ChunkRequestConsistent, ChunkRequestParallel } from './utils';
+/**
+ * Тип действия с типизированным payload
+ */
+export interface TypedAction<P> extends Action<P> {
+    type: string;
+    payload: P;
+}
+/**
+ * Тип для внешних состояний — Observable или хранилище (IStorageBase), которое автоматически конвертируется в Observable
+ */
+export type ExternalStates = Record<string, Observable<any> | IStorageBase<any>>;
+/**
+ * Контекст эффекта — объект с зависимостями, передаваемый третьим аргументом
+ */
+export interface EffectContext<TDispatcher = any, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> {
+    /** Основной dispatcher текущего synapse */
+    dispatcher: TDispatcher;
+    /** Внешние dispatcher'ы из других synapse */
+    externalDispatchers: TExternalDispatchers;
+    /** Внешние состояния — Observable'ы от других хранилищ (Synapse.state$, или любой Observable) */
+    externalStates: TExternalStates;
+    /** Сервисы (API-клиенты и т.д.) */
+    services: TServices;
+    /** Глобальная конфигурация для эффектов */
+    config: TConfig;
+}
+/**
+ * Тип для эффекта с доступом к состоянию и контексту — основной тип
+ */
+export type Effect<TState extends Record<string, any> = any, TDispatcher = any, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> = (action$: Observable<Action>, state$: Observable<TState>, context: EffectContext<TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>) => Observable<unknown>;
+/**
+ * Тип для получения типов действий диспетчера
+ */
+export type DispatcherActions<T> = T extends Dispatcher<any, infer A> ? ActionsResult<A> : Record<string, DispatchFunction<any, any>>;
+/**
+ * Конфигурация для валидации в validateMap
+ */
+export interface ValidateConfig {
+    conditions: boolean[];
+    skipAction: (() => any) | any | ((() => any) | any)[];
+}
+/**
+ * Утилиты для запросов в validateMap
+ */
+export interface ValidateMapRequestUtils {
+    chunkRequest: ChunkRequestParallel;
+    chunkRequestConsistent: ChunkRequestConsistent;
+}
+/**
+ * Оператор для фильтрации действий по типу с сохранением типа payload
+ */
+export declare function ofType<T extends DispatchFunction<any, any> | WatcherFunction<any>>(actionFn: T): OperatorFunction<Action, TypedAction<T extends WatcherFunction<infer R> ? R : ExtractResultType<T>>>;
+/**
+ * Оператор для фильтрации действий по нескольким типам с объединением типов payload
+ * @param actionFns Массив функций действий
+ */
+export declare function ofTypes<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): OperatorFunction<Action, TypedAction<ExtractResultType<T[number]>>>;
+/**
+ * Оператор для ожидания выполнения всех указанных действий.
+ *
+ * **Важно:** Использует `combineLatest` — Observable не эмитит, пока КАЖДЫЙ из
+ * указанных action не будет диспатчнут хотя бы один раз. Если хотя бы один action
+ * никогда не будет вызван, поток зависнет навсегда без уведомления.
+ * Убедитесь, что все указанные actions гарантированно будут диспатчнуты,
+ * либо используйте `ofTypes` с ручной агрегацией при необходимости таймаута.
+ *
+ * @param actionFns Массив функций действий
+ */
+export declare function ofTypesWaitAll<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): (source$: Observable<Action>) => Observable<{ [K in keyof T]: TypedAction<ExtractResultType<T[K]>>; }>;
+/**
+ * Создает Observable с выбранными данными из состояния
+ * @param state$ Поток состояния
+ * @param selectors Селекторы для выбора частей состояния
+ * @returns Observable с массивом выбранных значений
+ */
+export declare function selectorMap<TState, TResults extends any[]>(state$: Observable<TState>, ...selectors: {
+    [K in keyof TResults]: (state: TState) => TResults[K];
+}): Observable<TResults>;
+/**
+ * Создает именованный объект вместо массива
+ * @param state$ Поток состояния
+ * @param selectors Объект с селекторами
+ * @returns Observable с объектом выбранных значений
+ */
+export declare function selectorObject<TState, TResult extends Record<string, any>>(state$: Observable<TState>, selectors: {
+    [K in keyof TResult]: (state: TState) => TResult[K];
+}): Observable<TResult>;
+/**
+ * Оператор validateMap для валидации данных и условного вызова API
+ */
+export declare function validateMap<T, TResult = any>({ validator, loadingAction, errorAction, apiCall, }: {
+    validator?: (value: T) => ValidateConfig;
+    /** Вызывается после успешной валидации, перед apiCall. Типичное использование — dispatch loading-статуса. */
+    loadingAction?: (value: T) => void;
+    /** Вызывается при ошибке в apiCall (catchError). Получает ошибку + те же данные что loadingAction/apiCall. */
+    errorAction?: (error: any, value: T) => void;
+    apiCall: (value: T, utils: ValidateMapRequestUtils) => Observable<TResult>;
+}): OperatorFunction<T, any>;
+/**
+ * Метаданные ответа API, доступные в колбэках apiResult.
+ */
+export interface ApiResultMeta {
+    status: number;
+    statusText: string;
+    headers: Headers;
+    fromCache?: boolean;
+}
+/**
+ * Ошибка API-запроса. Бросается apiResult при !result.ok.
+ * Ловится errorAction в validateMap.
+ */
+export declare class ApiError extends Error {
+    readonly originalError: any;
+    readonly meta: ApiResultMeta;
+    constructor(originalError: any, meta: ApiResultMeta);
+}
+/**
+ * Оператор для обработки успешного результата API-запроса (QueryResult).
+ *
+ * При `result.ok` — вызывает callback с `data` и `meta`.
+ * При `!result.ok` — бросает `ApiError`, который ловится `errorAction` в `validateMap`.
+ *
+ * @example
+ * ```ts
+ * // Простой случай
+ * validateMap({
+ *   errorAction: (err) => dispatcher.dispatch.loadError(String(err)),
+ *   apiCall: () => from(api.request('getList', params)).pipe(
+ *     apiResult((data) => dispatcher.dispatch.loadSuccess(data)),
+ *   ),
+ * })
+ *
+ * // С доступом к headers (пагинация)
+ * apiResult((data, meta) => {
+ *   const total = Number(meta.headers.get('X-Total-Count'))
+ *   dispatcher.dispatch.loadSuccess({ items: data, total })
+ * })
+ * ```
+ */
+export declare function apiResult<TData, TResult = void>(onSuccess: (data: TData, meta: ApiResultMeta) => TResult | Promise<TResult>): OperatorFunction<{
+    ok: boolean;
+    data?: TData;
+    error?: any;
+    status?: number;
+    statusText?: string;
+    headers?: Headers;
+    fromCache?: boolean;
+}, TResult>;
+/**
+ * Класс для управления эффектами с поддержкой доступа к состоянию и контексту
+ * Основной класс, который следует использовать
+ */
+export declare class EffectsModule<TState extends Record<string, any> = any, TDispatcher = any, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> {
+    private storage;
+    private dispatcher;
+    private externalDispatchers;
+    private services;
+    private config;
+    private effects;
+    private subscriptions;
+    private running;
+    private action$;
+    private externalStates;
+    /**
+     * Поток состояния
+     */
+    readonly state$: Observable<TState>;
+    /**
+     * Создает модуль эффектов
+     * @param storage Хранилище состояния
+     * @param dispatcher Основной dispatcher текущего synapse
+     * @param externalDispatchers Внешние dispatcher'ы из других synapse
+     * @param services Сервисы (API-клиенты и т.д.)
+     * @param config Глобальная конфигурация для всех эффектов
+     * @param externalStates Внешние состояния (Observable'ы от других хранилищ)
+     */
+    constructor(storage: IStorage<TState>, dispatcher: TDispatcher & {
+        actions: Observable<Action>;
+    }, externalDispatchers?: TExternalDispatchers, services?: TServices, config?: TConfig, externalStates?: TExternalStates);
+    /**
+     * Нормализует externalStates: конвертирует IStorageBase в Observable, пропускает Observable как есть
+     */
+    private normalizeExternalStates;
+    /**
+     * Подписывается на действия от основного dispatcher'а и внешних dispatcher'ов
+     */
+    private subscribeToDispatchers;
+    add(effect: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>): this;
+    /**
+     * Добавляет несколько эффектов
+     * @param effects Эффекты для добавления
+     * @returns Текущий модуль
+     */
+    addEffects(effects: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>[]): this;
+    /**
+     * Запускает все эффекты
+     * @returns Текущий модуль
+     */
+    start(): Promise<this>;
+    /**
+     * Останавливает все эффекты
+     * @returns Текущий модуль
+     */
+    stop(): this;
+    /**
+     * Подписывается на конкретный эффект
+     * @param effect Эффект для подписки
+     */
+    private subscribeToEffect;
+}
+/**
+ * Вспомогательная функция для создания типизированного эффекта
+ */
+export declare function createEffect<TState extends Record<string, any>, TDispatcher = any, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(effect: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>): Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>;
+/**
+ * Объединяет несколько эффектов в один
+ * @param effects Эффекты для объединения
+ * @returns Объединенный эффект
+ */
+export declare function combineEffects<TState extends Record<string, any>, TDispatcher = any, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(...effects: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>[]): Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>;
+//# sourceMappingURL=effects.module.d.ts.map

package/dist/reactive/effects/effects.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.module.d.ts","sourceRoot":"","sources":["../../../src/reactive/effects/effects.module.ts"],"names":[],"mappings":"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"}

package/dist/reactive/effects/effects.module.js

@@ -0,0 +1,356 @@
+import { EMPTY, Observable, Subject, combineLatest, from, merge, of, pipe } from "rxjs";
+import { catchError, filter, map, share, switchMap, take } from "rxjs/operators";
+import { handleCallbackError, logError } from "../../_utils/error-handling.util.js";
+import { chunkRequestConsistent, chunkRequestParallel, isStorage, toObservable } from "./utils/index.js";
+
+
+
+
+
+
+
+
+
+/**
+ * Оператор для фильтрации действий по типу с сохранением типа payload
+ */ function ofType(actionFn) {
+    const { actionType } = actionFn;
+    if (!actionType) {
+        logError('ofType: action function does not have actionType property', actionFn, null, 'warn');
+        return filter(()=>false);
+    }
+    // Улучшенная реализация с явными типами
+    return (source$)=>{
+        return source$.pipe(filter((action)=>action !== undefined && action.type === actionType));
+    };
+}
+/**
+ * Оператор для фильтрации действий по нескольким типам с объединением типов payload
+ * @param actionFns Массив функций действий
+ */ function ofTypes(actionFns) {
+    // Получаем типы действий
+    const actionTypes = actionFns.map((fn)=>fn.actionType).filter(Boolean);
+    if (actionTypes.length === 0) {
+        logError('ofTypes: no valid action types found in array', actionFns, null, 'warn');
+        return filter(()=>false);
+    }
+    // Улучшенная реализация с явными типами
+    return (source$)=>{
+        return source$.pipe(filter((action)=>action !== undefined && actionTypes.includes(action.type)));
+    };
+}
+/**
+ * Оператор для ожидания выполнения всех указанных действий.
+ *
+ * **Важно:** Использует `combineLatest` — Observable не эмитит, пока КАЖДЫЙ из
+ * указанных action не будет диспатчнут хотя бы один раз. Если хотя бы один action
+ * никогда не будет вызван, поток зависнет навсегда без уведомления.
+ * Убедитесь, что все указанные actions гарантированно будут диспатчнуты,
+ * либо используйте `ofTypes` с ручной агрегацией при необходимости таймаута.
+ *
+ * @param actionFns Массив функций действий
+ */ function ofTypesWaitAll(actionFns) {
+    return (source$)=>{
+        // Создаем потоки для каждого типа действия
+        const actionTypes = actionFns.map((fn)=>fn.actionType).filter(Boolean);
+        if (actionTypes.length === 0) {
+            logError('ofTypesWaitAll: no valid action types found in array', actionFns, null, 'warn');
+            return of([]);
+        }
+        // Для каждого типа действия создаем поток,
+        // который берет первое срабатывание
+        const actionStreams = actionTypes.map((type, index)=>source$.pipe(filter((action)=>action.type === type), take(1), map((action)=>// Сохраняем ассоциацию с индексом, чтобы соответствовать
+                // порядку в исходном массиве actionFns
+                ({
+                    index,
+                    action
+                }))));
+        // Ждем, пока все потоки выдадут значения, и сортируем результаты
+        // по индексу для сохранения порядка
+        return combineLatest(actionStreams).pipe(map((results)=>{
+            // Сортируем по индексу
+            results.sort((a, b)=>a.index - b.index);
+            // Убираем индекс и возвращаем только действия
+            return results.map((r)=>r.action);
+        }));
+    };
+}
+/**
+ * Создает Observable с выбранными данными из состояния
+ * @param state$ Поток состояния
+ * @param selectors Селекторы для выбора частей состояния
+ * @returns Observable с массивом выбранных значений
+ */ function selectorMap(state$, ...selectors) {
+    return state$.pipe(map((state)=>{
+        return selectors.map((selector)=>selector(state));
+    }));
+}
+/**
+ * Создает именованный объект вместо массива
+ * @param state$ Поток состояния
+ * @param selectors Объект с селекторами
+ * @returns Observable с объектом выбранных значений
+ */ function selectorObject(state$, selectors) {
+    return state$.pipe(map((state)=>{
+        const result = {};
+        for (const [key, selector] of Object.entries(selectors)){
+            result[key] = selector(state);
+        }
+        return result;
+    }));
+}
+/**
+ * Оператор validateMap для валидации данных и условного вызова API
+ */ function validateMap({ validator, loadingAction, errorAction, apiCall }) {
+    return pipe(switchMap((pipeData)=>{
+        /**
+       * Функция вызова API-метода
+       */ const callApi = ()=>{
+            if (loadingAction) loadingAction(pipeData);
+            const apiCall$ = apiCall(pipeData, {
+                chunkRequest: chunkRequestParallel,
+                chunkRequestConsistent: chunkRequestConsistent
+            });
+            if (!errorAction) return apiCall$;
+            return apiCall$.pipe(catchError((err)=>{
+                errorAction(err, pipeData);
+                return EMPTY;
+            }));
+        };
+        /**
+       * Если валидацию не используем - сразу вызываем запрос
+       */ if (!validator) return callApi();
+        const validateConfig = validator(pipeData);
+        const { conditions, skipAction } = validateConfig;
+        const conditionMet = conditions.every(Boolean);
+        /**
+       * Если валидация не пройдена - вызываем экшн сброса
+       */ if (!conditionMet) {
+            if (Array.isArray(skipAction)) {
+                // eslint-disable-next-line no-unsafe-optional-chaining
+                return of(...skipAction?.filter(Boolean).map((action)=>typeof action === 'function' ? action() : action));
+            }
+            return of(typeof skipAction === 'function' ? skipAction() : skipAction);
+        }
+        return callApi();
+    }));
+}
+/**
+ * Ошибка API-запроса. Бросается apiResult при !result.ok.
+ * Ловится errorAction в validateMap.
+ */ class ApiError extends Error {
+    originalError;
+    meta;
+    constructor(originalError, meta){
+        super(typeof originalError === 'string' ? originalError : originalError?.message ?? 'API request failed'), this.originalError = originalError, this.meta = meta;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Оператор для обработки успешного результата API-запроса (QueryResult).
+ *
+ * При `result.ok` — вызывает callback с `data` и `meta`.
+ * При `!result.ok` — бросает `ApiError`, который ловится `errorAction` в `validateMap`.
+ *
+ * @example
+ * ```ts
+ * // Простой случай
+ * validateMap({
+ *   errorAction: (err) => dispatcher.dispatch.loadError(String(err)),
+ *   apiCall: () => from(api.request('getList', params)).pipe(
+ *     apiResult((data) => dispatcher.dispatch.loadSuccess(data)),
+ *   ),
+ * })
+ *
+ * // С доступом к headers (пагинация)
+ * apiResult((data, meta) => {
+ *   const total = Number(meta.headers.get('X-Total-Count'))
+ *   dispatcher.dispatch.loadSuccess({ items: data, total })
+ * })
+ * ```
+ */ function apiResult(onSuccess) {
+    return pipe(switchMap((result)=>{
+        const meta = {
+            status: result.status ?? 0,
+            statusText: result.statusText ?? '',
+            headers: result.headers ?? new Headers(),
+            fromCache: result.fromCache
+        };
+        if (result.ok && result.data !== undefined) {
+            const out = onSuccess(result.data, meta);
+            return from(Promise.resolve(out));
+        }
+        throw new ApiError(result.error ?? 'Unknown error', meta);
+    }));
+}
+/**
+ * Класс для управления эффектами с поддержкой доступа к состоянию и контексту
+ * Основной класс, который следует использовать
+ */ class EffectsModule {
+    storage;
+    dispatcher;
+    externalDispatchers;
+    services;
+    config;
+    effects = [];
+    subscriptions = [];
+    running = false;
+    action$ = new Subject();
+    externalStates;
+    /**
+   * Поток состояния
+   */ state$;
+    /**
+   * Создает модуль эффектов
+   * @param storage Хранилище состояния
+   * @param dispatcher Основной dispatcher текущего synapse
+   * @param externalDispatchers Внешние dispatcher'ы из других synapse
+   * @param services Сервисы (API-клиенты и т.д.)
+   * @param config Глобальная конфигурация для всех эффектов
+   * @param externalStates Внешние состояния (Observable'ы от других хранилищ)
+   */ constructor(storage, dispatcher, externalDispatchers = {}, services = {}, config = {}, externalStates = {}){
+        this.storage = storage;
+        this.dispatcher = dispatcher;
+        this.externalDispatchers = externalDispatchers;
+        this.services = services;
+        this.config = config;
+        // Нормализуем externalStates: конвертируем storage → Observable
+        this.externalStates = this.normalizeExternalStates(externalStates);
+        // Создаем поток состояния
+        this.state$ = new Observable((observer)=>{
+            // Отправляем начальное состояние
+            Promise.resolve(this.storage.getState()).then((state)=>observer.next(state));
+            // Подписываемся на все изменения
+            const unsubscribe = this.storage.subscribeToAll(()=>{
+                Promise.resolve(this.storage.getState()).then((state)=>observer.next(state));
+            });
+            // Отписываемся при завершении
+            return ()=>unsubscribe();
+        }).pipe(share());
+    }
+    /**
+   * Нормализует externalStates: конвертирует IStorageBase в Observable, пропускает Observable как есть
+   */ normalizeExternalStates(states) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(states)){
+            normalized[key] = isStorage(value) ? toObservable(value) : value;
+        }
+        return normalized;
+    }
+    /**
+   * Подписывается на действия от основного dispatcher'а и внешних dispatcher'ов
+   */ subscribeToDispatchers() {
+        // Основной dispatcher
+        const mainSub = this.dispatcher.actions.subscribe((action)=>{
+            this.action$.next(action);
+        });
+        this.subscriptions.push(mainSub);
+        // Внешние dispatcher'ы
+        for (const [_, dispatcher] of Object.entries(this.externalDispatchers)){
+            const subscription = dispatcher.actions.subscribe((action)=>{
+                this.action$.next(action);
+            });
+            this.subscriptions.push(subscription);
+        }
+    }
+    add(effect) {
+        this.effects.push(effect);
+        if (this.running) {
+            this.subscribeToEffect(effect);
+        }
+        return this;
+    }
+    /**
+   * Добавляет несколько эффектов
+   * @param effects Эффекты для добавления
+   * @returns Текущий модуль
+   */ addEffects(effects) {
+        effects.forEach((effect)=>this.add(effect));
+        return this;
+    }
+    /**
+   * Запускает все эффекты
+   * @returns Текущий модуль
+   */ async start() {
+        if (this.running) {
+            return this;
+        }
+        // Ждем готовности основного хранилища
+        await this.storage.waitForReady();
+        // Переподписываемся на dispatchers (подписки были очищены в stop())
+        this.subscribeToDispatchers();
+        this.effects.forEach((effect)=>this.subscribeToEffect(effect));
+        this.running = true;
+        return this;
+    }
+    /**
+   * Останавливает все эффекты
+   * @returns Текущий модуль
+   */ stop() {
+        this.subscriptions.forEach((sub)=>sub.unsubscribe());
+        this.subscriptions = [];
+        this.action$.complete();
+        this.action$ = new Subject();
+        this.running = false;
+        return this;
+    }
+    /**
+   * Подписывается на конкретный эффект
+   * @param effect Эффект для подписки
+   */ subscribeToEffect(effect) {
+        try {
+            const context = {
+                dispatcher: this.dispatcher,
+                externalDispatchers: this.externalDispatchers,
+                externalStates: this.externalStates,
+                services: this.services,
+                config: this.config
+            };
+            const output$ = effect(this.action$.asObservable(), this.state$, context).pipe(catchError((err)=>{
+                handleCallbackError('EffectsModule: error in effect', err);
+                return of(null);
+            }));
+            const subscription = output$.subscribe((result)=>{
+                if (result === null || result === undefined) {
+                    return;
+                }
+                if (typeof result === 'function') {
+                    try {
+                        result();
+                    } catch (callError) {
+                        handleCallbackError('EffectsModule: error calling effect result function', callError);
+                    }
+                }
+            });
+            this.subscriptions.push(subscription);
+        } catch (setupError) {
+            handleCallbackError('EffectsModule: error setting up effect', setupError);
+        }
+    }
+}
+/**
+ * Вспомогательная функция для создания типизированного эффекта
+ */ function createEffect(effect) {
+    return effect;
+}
+/**
+ * Объединяет несколько эффектов в один
+ * @param effects Эффекты для объединения
+ * @returns Объединенный эффект
+ */ function combineEffects(...effects) {
+    return (action$, state$, context)=>{
+        const outputs = effects.map((effect)=>{
+            try {
+                return effect(action$, state$, context);
+            } catch (error) {
+                handleCallbackError('combineEffects: error in one of combined effects', error);
+                return of(null);
+            }
+        });
+        return merge(...outputs);
+    };
+}
+
+export { ApiError, EffectsModule, apiResult, combineEffects, createEffect, ofType, ofTypes, ofTypesWaitAll, selectorMap, selectorObject, validateMap };
+
+//# sourceMappingURL=effects.module.js.map