synapse-storage 3.0.19 → 4.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/effects.module.js","sources":["../../../src/reactive/effects/effects.module.ts"],"sourcesContent":["import { combineLatest, EMPTY, from, merge, Observable, of, OperatorFunction, pipe, Subject } from 'rxjs'\nimport { catchError, filter, map, share, switchMap, take } from 'rxjs/operators'\n\nimport { handleCallbackError, logError } from '../../_utils/error-handling.util'\nimport { IStorage, IStorageBase } from '../../core'\nimport { Action, ActionsResult, Dispatcher, DispatchFunction, ExtractResultType, WatcherFunction } from '../dispatcher'\nimport { ChunkRequestConsistent, chunkRequestConsistent, ChunkRequestParallel, chunkRequestParallel, isStorage, toObservable } from './utils'\n\n/**\n * Тип действия с типизированным payload\n */\nexport interface TypedAction<P> extends Action<P> {\n  type: string\n  payload: P\n}\n\n/**\n * Тип для внешних состояний — Observable или хранилище (IStorageBase), которое автоматически конвертируется в Observable\n */\nexport type ExternalStates = Record<string, Observable<any> | IStorageBase<any>>\n\n/**\n * Контекст эффекта — объект с зависимостями, передаваемый третьим аргументом\n */\nexport interface EffectContext<\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>,\n  TExternalStates extends ExternalStates = Record<string, never>,\n> {\n  /** Основной dispatcher текущего synapse */\n  dispatcher: TDispatcher\n  /** Внешние dispatcher'ы из других synapse */\n  externalDispatchers: TExternalDispatchers\n  /** Внешние состояния — Observable'ы от других хранилищ (Synapse.state$, или любой Observable) */\n  externalStates: TExternalStates\n  /** Сервисы (API-клиенты и т.д.) */\n  services: TServices\n  /** Глобальная конфигурация для эффектов */\n  config: TConfig\n}\n\n/**\n * Тип для эффекта с доступом к состоянию и контексту — основной тип\n */\nexport type Effect<\n  TState extends Record<string, any> = any,\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>,\n  TExternalStates extends ExternalStates = Record<string, never>,\n> = (action$: Observable<Action>, state$: Observable<TState>, context: EffectContext<TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>) => Observable<unknown>\n\n/**\n * Тип для получения типов действий диспетчера\n */\nexport type DispatcherActions<T> = T extends Dispatcher<any, infer A> ? ActionsResult<A> : Record<string, DispatchFunction<any, any>>\n\n/**\n * Конфигурация для валидации в validateMap\n */\nexport interface ValidateConfig {\n  conditions: boolean[]\n  skipAction: (() => any) | any | ((() => any) | any)[]\n}\n\n/**\n * Утилиты для запросов в validateMap\n */\nexport interface ValidateMapRequestUtils {\n  chunkRequest: ChunkRequestParallel\n  chunkRequestConsistent: ChunkRequestConsistent\n}\n\n/**\n * Оператор для фильтрации действий по типу с сохранением типа payload\n */\nexport function ofType<T extends DispatchFunction<any, any> | WatcherFunction<any>>(\n  actionFn: T,\n): OperatorFunction<Action, TypedAction<T extends WatcherFunction<infer R> ? R : ExtractResultType<T>>> {\n  const { actionType } = actionFn\n\n  if (!actionType) {\n    logError('ofType: action function does not have actionType property', actionFn, null, 'warn')\n    return filter(() => false) as any\n  }\n\n  // Определяем тип payload в зависимости от типа функции\n  type PayloadType = T extends WatcherFunction<infer R> ? R : ExtractResultType<T>\n\n  // Улучшенная реализация с явными типами\n  return (source$: Observable<Action>): Observable<TypedAction<PayloadType>> => {\n    return source$.pipe(filter((action): action is TypedAction<PayloadType> => action !== undefined && action.type === actionType))\n  }\n}\n\n/**\n * Оператор для фильтрации действий по нескольким типам с объединением типов payload\n * @param actionFns Массив функций действий\n */\nexport function ofTypes<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): OperatorFunction<Action, TypedAction<ExtractResultType<T[number]>>> {\n  // Получаем типы действий\n  const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean)\n\n  if (actionTypes.length === 0) {\n    logError('ofTypes: no valid action types found in array', actionFns, null, 'warn')\n    return filter(() => false) as OperatorFunction<Action, TypedAction<ExtractResultType<T[number]>>>\n  }\n\n  // Union тип для payload из всех действий\n  type CombinedPayloadType = ExtractResultType<T[number]>\n\n  // Улучшенная реализация с явными типами\n  return (source$: Observable<Action>): Observable<TypedAction<CombinedPayloadType>> => {\n    return source$.pipe(filter((action): action is TypedAction<CombinedPayloadType> => action !== undefined && actionTypes.includes(action.type)))\n  }\n}\n\n/**\n * Оператор для ожидания выполнения всех указанных действий.\n *\n * **Важно:** Использует `combineLatest` — Observable не эмитит, пока КАЖДЫЙ из\n * указанных action не будет диспатчнут хотя бы один раз. Если хотя бы один action\n * никогда не будет вызван, поток зависнет навсегда без уведомления.\n * Убедитесь, что все указанные actions гарантированно будут диспатчнуты,\n * либо используйте `ofTypes` с ручной агрегацией при необходимости таймаута.\n *\n * @param actionFns Массив функций действий\n */\nexport function ofTypesWaitAll<T extends DispatchFunction<any, any>[]>(actionFns: [...T]) {\n  return (source$: Observable<Action>): Observable<{ [K in keyof T]: TypedAction<ExtractResultType<T[K]>> }> => {\n    // Создаем потоки для каждого типа действия\n    const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean)\n\n    if (actionTypes.length === 0) {\n      logError('ofTypesWaitAll: no valid action types found in array', actionFns, null, 'warn')\n      return of([]) as any\n    }\n\n    // Для каждого типа действия создаем поток,\n    // который берет первое срабатывание\n    const actionStreams = actionTypes.map((type, index) =>\n      source$.pipe(\n        filter((action) => action.type === type),\n        take(1),\n        map((action) =>\n          // Сохраняем ассоциацию с индексом, чтобы соответствовать\n          // порядку в исходном массиве actionFns\n          ({ index, action }),\n        ),\n      ),\n    )\n\n    // Ждем, пока все потоки выдадут значения, и сортируем результаты\n    // по индексу для сохранения порядка\n    return combineLatest(actionStreams).pipe(\n      map((results) => {\n        // Сортируем по индексу\n        results.sort((a, b) => a.index - b.index)\n        // Убираем индекс и возвращаем только действия\n        return results.map((r) => r.action) as any\n      }),\n    )\n  }\n}\n\n/**\n * Создает Observable с выбранными данными из состояния\n * @param state$ Поток состояния\n * @param selectors Селекторы для выбора частей состояния\n * @returns Observable с массивом выбранных значений\n */\nexport function selectorMap<TState, TResults extends any[]>(\n  state$: Observable<TState>,\n  ...selectors: { [K in keyof TResults]: (state: TState) => TResults[K] }\n): Observable<TResults> {\n  return state$.pipe(\n    map((state) => {\n      return selectors.map((selector) => selector(state)) as TResults\n    }),\n  )\n}\n\n/**\n * Создает именованный объект вместо массива\n * @param state$ Поток состояния\n * @param selectors Объект с селекторами\n * @returns Observable с объектом выбранных значений\n */\nexport function selectorObject<TState, TResult extends Record<string, any>>(\n  state$: Observable<TState>,\n  selectors: { [K in keyof TResult]: (state: TState) => TResult[K] },\n): Observable<TResult> {\n  return state$.pipe(\n    map((state) => {\n      const result = {} as TResult\n      for (const [key, selector] of Object.entries(selectors)) {\n        result[key as keyof TResult] = selector(state)\n      }\n      return result\n    }),\n  )\n}\n\n/**\n * Оператор validateMap для валидации данных и условного вызова API\n */\nexport function validateMap<T, TResult = any>({\n  validator,\n  loadingAction,\n  errorAction,\n  apiCall,\n}: {\n  validator?: (value: T) => ValidateConfig\n  /** Вызывается после успешной валидации, перед apiCall. Типичное использование — dispatch loading-статуса. */\n  loadingAction?: (value: T) => void\n  /** Вызывается при ошибке в apiCall (catchError). Получает ошибку + те же данные что loadingAction/apiCall. */\n  errorAction?: (error: any, value: T) => void\n  apiCall: (value: T, utils: ValidateMapRequestUtils) => Observable<TResult>\n}): OperatorFunction<T, any> {\n  return pipe(\n    switchMap((pipeData) => {\n      /**\n       * Функция вызова API-метода\n       */\n      const callApi = () => {\n        if (loadingAction) loadingAction(pipeData)\n\n        const apiCall$ = apiCall(pipeData, {\n          chunkRequest: chunkRequestParallel,\n          chunkRequestConsistent: chunkRequestConsistent,\n        })\n\n        if (!errorAction) return apiCall$\n\n        return apiCall$.pipe(\n          catchError((err) => {\n            errorAction(err, pipeData)\n            return EMPTY\n          }),\n        )\n      }\n\n      /**\n       * Если валидацию не используем - сразу вызываем запрос\n       */\n      if (!validator) return callApi()\n\n      const validateConfig = validator(pipeData)\n      const { conditions, skipAction } = validateConfig\n      const conditionMet = conditions.every(Boolean)\n\n      /**\n       * Если валидация не пройдена - вызываем экшн сброса\n       */\n      if (!conditionMet) {\n        if (Array.isArray(skipAction)) {\n          // eslint-disable-next-line no-unsafe-optional-chaining\n          return of(...skipAction?.filter(Boolean).map((action) => (typeof action === 'function' ? action() : action)))\n        }\n        return of(typeof skipAction === 'function' ? skipAction() : skipAction)\n      }\n\n      return callApi()\n    }),\n  )\n}\n\n/**\n * Метаданные ответа API, доступные в колбэках apiResult.\n */\nexport interface ApiResultMeta {\n  status: number\n  statusText: string\n  headers: Headers\n  fromCache?: boolean\n}\n\n/**\n * Ошибка API-запроса. Бросается apiResult при !result.ok.\n * Ловится errorAction в validateMap.\n */\nexport class ApiError extends Error {\n  constructor(\n    public readonly originalError: any,\n    public readonly meta: ApiResultMeta,\n  ) {\n    super(typeof originalError === 'string' ? originalError : (originalError?.message ?? 'API request failed'))\n    this.name = 'ApiError'\n  }\n}\n\n/**\n * Оператор для обработки успешного результата API-запроса (QueryResult).\n *\n * При `result.ok` — вызывает callback с `data` и `meta`.\n * При `!result.ok` — бросает `ApiError`, который ловится `errorAction` в `validateMap`.\n *\n * @example\n * ```ts\n * // Простой случай\n * validateMap({\n *   errorAction: (err) => dispatcher.dispatch.loadError(String(err)),\n *   apiCall: () => from(api.request('getList', params)).pipe(\n *     apiResult((data) => dispatcher.dispatch.loadSuccess(data)),\n *   ),\n * })\n *\n * // С доступом к headers (пагинация)\n * apiResult((data, meta) => {\n *   const total = Number(meta.headers.get('X-Total-Count'))\n *   dispatcher.dispatch.loadSuccess({ items: data, total })\n * })\n * ```\n */\nexport function apiResult<TData, TResult = void>(\n  onSuccess: (data: TData, meta: ApiResultMeta) => TResult | Promise<TResult>,\n): OperatorFunction<{ ok: boolean; data?: TData; error?: any; status?: number; statusText?: string; headers?: Headers; fromCache?: boolean }, TResult> {\n  return pipe(\n    switchMap((result) => {\n      const meta: ApiResultMeta = {\n        status: result.status ?? 0,\n        statusText: result.statusText ?? '',\n        headers: result.headers ?? new Headers(),\n        fromCache: result.fromCache,\n      }\n      if (result.ok && result.data !== undefined) {\n        const out = onSuccess(result.data, meta)\n        return from(Promise.resolve(out))\n      }\n      throw new ApiError(result.error ?? 'Unknown error', meta)\n    }),\n  )\n}\n\n/**\n * Класс для управления эффектами с поддержкой доступа к состоянию и контексту\n * Основной класс, который следует использовать\n */\nexport class EffectsModule<\n  TState extends Record<string, any> = any,\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>,\n  TExternalStates extends ExternalStates = Record<string, never>,\n> {\n  private effects: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>[] = []\n  private subscriptions: Array<{ unsubscribe: VoidFunction }> = []\n  private running = false\n  private action$ = new Subject<Action>()\n  private externalStates: TExternalStates\n\n  /**\n   * Поток состояния\n   */\n  public readonly state$: Observable<TState>\n\n  /**\n   * Создает модуль эффектов\n   * @param storage Хранилище состояния\n   * @param dispatcher Основной dispatcher текущего synapse\n   * @param externalDispatchers Внешние dispatcher'ы из других synapse\n   * @param services Сервисы (API-клиенты и т.д.)\n   * @param config Глобальная конфигурация для всех эффектов\n   * @param externalStates Внешние состояния (Observable'ы от других хранилищ)\n   */\n  constructor(\n    private storage: IStorage<TState>,\n    private dispatcher: TDispatcher & { actions: Observable<Action> },\n    private externalDispatchers: TExternalDispatchers = {} as TExternalDispatchers,\n    private services: TServices = {} as TServices,\n    private config: TConfig = {} as TConfig,\n    externalStates: TExternalStates = {} as TExternalStates,\n  ) {\n    // Нормализуем externalStates: конвертируем storage → Observable\n    this.externalStates = this.normalizeExternalStates(externalStates)\n\n    // Создаем поток состояния\n    this.state$ = new Observable<TState>((observer) => {\n      // Отправляем начальное состояние\n      Promise.resolve(this.storage.getState()).then((state: TState) => observer.next(state))\n\n      // Подписываемся на все изменения\n      const unsubscribe = this.storage.subscribeToAll(() => {\n        Promise.resolve(this.storage.getState()).then((state: TState) => observer.next(state))\n      })\n\n      // Отписываемся при завершении\n      return () => unsubscribe()\n    }).pipe(share())\n  }\n\n  /**\n   * Нормализует externalStates: конвертирует IStorageBase в Observable, пропускает Observable как есть\n   */\n  private normalizeExternalStates(states: TExternalStates): TExternalStates {\n    const normalized = {} as Record<string, Observable<any>>\n    for (const [key, value] of Object.entries(states)) {\n      normalized[key] = isStorage(value) ? toObservable(value) : value\n    }\n    return normalized as TExternalStates\n  }\n\n  /**\n   * Подписывается на действия от основного dispatcher'а и внешних dispatcher'ов\n   */\n  private subscribeToDispatchers() {\n    // Основной dispatcher\n    const mainSub = this.dispatcher.actions.subscribe((action) => {\n      this.action$.next(action)\n    })\n    this.subscriptions.push(mainSub)\n\n    // Внешние dispatcher'ы\n    for (const [_, dispatcher] of Object.entries(this.externalDispatchers)) {\n      const subscription = dispatcher.actions.subscribe((action) => {\n        this.action$.next(action)\n      })\n      this.subscriptions.push(subscription)\n    }\n  }\n\n  add(effect: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>): this {\n    this.effects.push(effect)\n\n    if (this.running) {\n      this.subscribeToEffect(effect)\n    }\n\n    return this\n  }\n\n  /**\n   * Добавляет несколько эффектов\n   * @param effects Эффекты для добавления\n   * @returns Текущий модуль\n   */\n  addEffects(effects: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>[]): this {\n    effects.forEach((effect) => this.add(effect))\n    return this\n  }\n\n  /**\n   * Запускает все эффекты\n   * @returns Текущий модуль\n   */\n  async start(): Promise<this> {\n    if (this.running) {\n      return this\n    }\n    // Ждем готовности основного хранилища\n    await this.storage.waitForReady()\n\n    // Переподписываемся на dispatchers (подписки были очищены в stop())\n    this.subscribeToDispatchers()\n\n    this.effects.forEach((effect) => this.subscribeToEffect(effect))\n    this.running = true\n\n    return this\n  }\n\n  /**\n   * Останавливает все эффекты\n   * @returns Текущий модуль\n   */\n  stop(): this {\n    this.subscriptions.forEach((sub) => sub.unsubscribe())\n    this.subscriptions = []\n    this.action$.complete()\n    this.action$ = new Subject<Action>()\n    this.running = false\n\n    return this\n  }\n\n  /**\n   * Подписывается на конкретный эффект\n   * @param effect Эффект для подписки\n   */\n  private subscribeToEffect(effect: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>): void {\n    try {\n      const context: EffectContext<TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates> = {\n        dispatcher: this.dispatcher,\n        externalDispatchers: this.externalDispatchers,\n        externalStates: this.externalStates,\n        services: this.services,\n        config: this.config,\n      }\n\n      const output$ = effect(this.action$.asObservable(), this.state$, context).pipe(\n        catchError((err) => {\n          handleCallbackError('EffectsModule: error in effect', err)\n          return of(null)\n        }),\n      )\n\n      const subscription = output$.subscribe((result) => {\n        if (result === null || result === undefined) {\n          return\n        }\n\n        if (typeof result === 'function') {\n          try {\n            result()\n          } catch (callError) {\n            handleCallbackError('EffectsModule: error calling effect result function', callError)\n          }\n        }\n      })\n\n      this.subscriptions.push(subscription)\n    } catch (setupError) {\n      handleCallbackError('EffectsModule: error setting up effect', setupError)\n    }\n  }\n}\n\n/**\n * Вспомогательная функция для создания типизированного эффекта\n */\nexport function createEffect<\n  TState extends Record<string, any>,\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>,\n  TExternalStates extends ExternalStates = Record<string, never>,\n>(\n  effect: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>,\n): Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates> {\n  return effect\n}\n\n/**\n * Объединяет несколько эффектов в один\n * @param effects Эффекты для объединения\n * @returns Объединенный эффект\n */\nexport function combineEffects<\n  TState extends Record<string, any>,\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>,\n  TExternalStates extends ExternalStates = Record<string, never>,\n>(\n  ...effects: Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates>[]\n): Effect<TState, TDispatcher, TServices, TConfig, TExternalDispatchers, TExternalStates> {\n  return (action$, state$, context) => {\n    const outputs = effects.map((effect) => {\n      try {\n        return effect(action$, state$, context)\n      } catch (error) {\n        handleCallbackError('combineEffects: error in one of combined effects', error)\n        return of(null)\n      }\n    })\n    return merge(...outputs)\n  }\n}\n"],"names":["combineLatest","EMPTY","from","merge","Observable","of","pipe","Subject","catchError","filter","map","share","switchMap","take","handleCallbackError","logError","chunkRequestConsistent","chunkRequestParallel","isStorage","toObservable","ofType","actionFn","actionType","source$","action","undefined","ofTypes","actionFns","actionTypes","fn","Boolean","ofTypesWaitAll","actionStreams","type","index","results","a","b","r","selectorMap","state$","selectors","state","selector","selectorObject","result","key","Object","validateMap","validator","loadingAction","errorAction","apiCall","pipeData","callApi","apiCall$","err","validateConfig","conditions","skipAction","conditionMet","Array","ApiError","Error","originalError","meta","apiResult","onSuccess","Headers","out","Promise","EffectsModule","storage","dispatcher","externalDispatchers","services","config","externalStates","observer","unsubscribe","states","normalized","value","mainSub","_","subscription","effect","effects","sub","context","output$","callError","setupError","createEffect","combineEffects","action$","outputs","error"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+export * from './effects.module';
+export { fromRequest } from './utils/fromRequest';
+export { toObservable } from './utils/toObservable';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reactive/effects/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/reactive/effects/index.js

@@ -0,0 +1,11 @@
+export * from "./effects.module.js";
+
+
+
+
+
+
+export { fromRequest } from "./utils/fromRequest.js";
+export { toObservable } from "./utils/toObservable.js";
+
+//# sourceMappingURL=index.js.map

package/dist/reactive/effects/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/index.js","sources":["../../../src/reactive/effects/index.ts"],"sourcesContent":["export * from './effects.module'\nexport { fromRequest } from './utils/fromRequest'\nexport { toObservable } from './utils/toObservable'\n"],"names":["fromRequest","toObservable"],"mappings":";;;AAAgC;AACiB;AACE"}

package/dist/reactive/effects/utils/chunkRequestConsistent.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПОСЛЕДОВАТЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+export declare const chunkRequestConsistent: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+export type ChunkRequestConsistent = typeof chunkRequestConsistent;
+//# sourceMappingURL=chunkRequestConsistent.d.ts.map

package/dist/reactive/effects/utils/chunkRequestConsistent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkRequestConsistent.d.ts","sourceRoot":"","sources":["../../../../src/reactive/effects/utils/chunkRequestConsistent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAM,MAAM,MAAM,CAAA;AAKrC;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,MAAM,MAAM,EAAE,gBAAW,KAAG,UAAU,CAAC,CAAC,EAAE,CAGnI,CAAA;AACD,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA"}

package/dist/reactive/effects/utils/chunkRequestConsistent.js

@@ -0,0 +1,25 @@
+import { of } from "rxjs";
+import { concatAll, delay, mergeMap, toArray } from "rxjs/operators";
+import { chunk } from "../../../_utils/index.js";
+
+
+
+
+
+
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПОСЛЕДОВАТЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */ const chunkRequestConsistent = (fn, arr, size, delayMs = 0)=>{
+    const chunks = chunk(arr, size).map((chunkItem)=>of(chunkItem).pipe(delay(delayMs), mergeMap(fn)));
+    return of(...chunks).pipe(concatAll(), toArray());
+};
+
+export { chunkRequestConsistent };
+
+//# sourceMappingURL=chunkRequestConsistent.js.map

package/dist/reactive/effects/utils/chunkRequestConsistent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/utils/chunkRequestConsistent.js","sources":["../../../../src/reactive/effects/utils/chunkRequestConsistent.ts"],"sourcesContent":["import { Observable, of } from 'rxjs'\nimport { concatAll, delay, mergeMap, toArray } from 'rxjs/operators'\n\nimport { chunk } from '../../../_utils'\n\n/**\n * Разбиение запроса на порции\n * Отправляется ПОСЛЕДОВАТЕЛЬНО n-запросов и дожидается ответа от каждого\n * @param fn - функция в которую передается chunk и возвращается функция api\n * @param arr - массив который нужно поделить\n * @param size - размер порции\n * @param delayMs - задержка между запросами в миллисекундах\n */\nexport const chunkRequestConsistent = <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs = 0): Observable<R[]> => {\n  const chunks = chunk(arr, size).map((chunkItem) => of(chunkItem).pipe(delay(delayMs), mergeMap(fn)))\n  return of(...chunks).pipe(concatAll(), toArray())\n}\nexport type ChunkRequestConsistent = typeof chunkRequestConsistent\n"],"names":["of","concatAll","delay","mergeMap","toArray","chunk","chunkRequestConsistent","fn","arr","size","delayMs","chunks","chunkItem"],"mappings":";;;;;;;AAAqC;AAC+B;AAE7B;AAEvC;;;;;;;CAOC,GACM,MAAMM,sBAAsBA,GAAG,CAAOC,IAAmCC,KAAUC,MAAcC,UAAU,CAAC;IACjH,MAAMC,SAASN,KAAKA,CAACG,KAAKC,MAAM,GAAG,CAAC,CAACG,YAAcZ,EAAEA,CAACY,WAAW,IAAI,CAACV,KAAKA,CAACQ,UAAUP,QAAQA,CAACI;IAC/F,OAAOP,EAAEA,IAAIW,QAAQ,IAAI,CAACV,SAASA,IAAIG,OAAOA;AAChD,EAAC"}

package/dist/reactive/effects/utils/chunkRequestParallel.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПАРАЛЛЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+export declare const chunkRequestParallel: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+export type ChunkRequestParallel = typeof chunkRequestParallel;
+//# sourceMappingURL=chunkRequestParallel.d.ts.map

package/dist/reactive/effects/utils/chunkRequestParallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkRequestParallel.d.ts","sourceRoot":"","sources":["../../../../src/reactive/effects/utils/chunkRequestParallel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAS,MAAM,MAAM,CAAA;AAKlD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,MAAM,MAAM,EAAE,gBAAW,KAAG,UAAU,CAAC,CAAC,EAAE,CAChB,CAAA;AAClH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/reactive/effects/utils/chunkRequestParallel.js

@@ -0,0 +1,22 @@
+import { forkJoin, timer } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+import { chunk } from "../../../_utils/index.js";
+
+
+
+
+
+
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПАРАЛЛЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */ const chunkRequestParallel = (fn, arr, size, delayMs = 0)=>forkJoin(chunk(arr, size).map((chunkItem, index)=>timer(index * delayMs).pipe(mergeMap(()=>fn(chunkItem)))));
+
+export { chunkRequestParallel };
+
+//# sourceMappingURL=chunkRequestParallel.js.map

package/dist/reactive/effects/utils/chunkRequestParallel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/utils/chunkRequestParallel.js","sources":["../../../../src/reactive/effects/utils/chunkRequestParallel.ts"],"sourcesContent":["import { forkJoin, Observable, timer } from 'rxjs'\nimport { mergeMap } from 'rxjs/operators'\n\nimport { chunk } from '../../../_utils'\n\n/**\n * Разбиение запроса на порции\n * Отправляется ПАРАЛЛЕЛЬНО n-запросов и дожидается ответа от каждого\n * @param fn - функция в которую передается chunk и возвращается функция api\n * @param arr - массив который нужно поделить\n * @param size - размер порции\n * @param delayMs - задержка между запросами в миллисекундах\n */\nexport const chunkRequestParallel = <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs = 0): Observable<R[]> =>\n  forkJoin(chunk(arr, size).map((chunkItem, index) => timer(index * delayMs).pipe(mergeMap(() => fn(chunkItem)))))\nexport type ChunkRequestParallel = typeof chunkRequestParallel\n"],"names":["forkJoin","timer","mergeMap","chunk","chunkRequestParallel","fn","arr","size","delayMs","chunkItem","index"],"mappings":";;;;;;;AAAkD;AACT;AAEF;AAEvC;;;;;;;CAOC,GACM,MAAMI,oBAAoBA,GAAG,CAAOC,IAAmCC,KAAUC,MAAcC,UAAU,CAAC,GAC/GR,QAAQA,CAACG,KAAKA,CAACG,KAAKC,MAAM,GAAG,CAAC,CAACE,WAAWC,QAAUT,KAAKA,CAACS,QAAQF,SAAS,IAAI,CAACN,QAAQA,CAAC,IAAMG,GAAGI,eAAc"}

package/dist/reactive/effects/utils/fromRequest.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import type { RequestResponseModify } from '../../../api/types/endpoint.interface';
+import type { QueryResult } from '../../../api/types/query.interface';
+/**
+ * Конвертирует `RequestResponseModify` в Observable с поддержкой отмены запроса.
+ *
+ * **Зачем нужен:**
+ * `RequestResponseModify` — thenable-объект (имеет `.then()`), поэтому RxJS `from()`
+ * может конвертировать его в Observable напрямую. Однако при таком подходе теряется
+ * возможность отмены: когда RxJS отписывается от Observable (switchMap, takeUntil,
+ * unsubscribe), Promise продолжает висеть — HTTP-запрос не абортится.
+ *
+ * `fromRequest` создаёт Observable с teardown-функцией, которая вызывает `req.abort()`
+ * при отписке. Это гарантирует, что при переключении на новый запрос (switchMap)
+ * или остановке эффектов предыдущий HTTP-запрос будет реально отменён.
+ *
+ * Abort вызывается только если запрос ещё не завершился — при нормальном завершении
+ * (resolve/reject) teardown не абортит, чтобы не влиять на внутреннее состояние endpoint'а.
+ *
+ * @example
+ * ```ts
+ * import { fromRequest } from 'synapse-storage/reactive'
+ *
+ * // Вместо:
+ * from(getList.request({ limit: 20, offset: 0 }))
+ *
+ * // Используйте:
+ * fromRequest(getList.request({ limit: 20, offset: 0 }))
+ *
+ * // В эффекте с validateMap:
+ * apiCall: ([_action, _state, { pageSize }]) =>
+ *   fromRequest(getList.request({ limit: pageSize, offset: 0 })).pipe(
+ *     apiResult((data) => {
+ *       dispatcher.dispatch.applyList(data)
+ *     }),
+ *   ),
+ * ```
+ */
+export declare function fromRequest<T>(req: RequestResponseModify<T>): Observable<QueryResult<T, Error>>;
+//# sourceMappingURL=fromRequest.d.ts.map

package/dist/reactive/effects/utils/fromRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromRequest.d.ts","sourceRoot":"","sources":["../../../../src/reactive/effects/utils/fromRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAEjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CA0B/F"}

package/dist/reactive/effects/utils/fromRequest.js

@@ -0,0 +1,64 @@
+import { Observable } from "rxjs";
+
+
+
+/**
+ * Конвертирует `RequestResponseModify` в Observable с поддержкой отмены запроса.
+ *
+ * **Зачем нужен:**
+ * `RequestResponseModify` — thenable-объект (имеет `.then()`), поэтому RxJS `from()`
+ * может конвертировать его в Observable напрямую. Однако при таком подходе теряется
+ * возможность отмены: когда RxJS отписывается от Observable (switchMap, takeUntil,
+ * unsubscribe), Promise продолжает висеть — HTTP-запрос не абортится.
+ *
+ * `fromRequest` создаёт Observable с teardown-функцией, которая вызывает `req.abort()`
+ * при отписке. Это гарантирует, что при переключении на новый запрос (switchMap)
+ * или остановке эффектов предыдущий HTTP-запрос будет реально отменён.
+ *
+ * Abort вызывается только если запрос ещё не завершился — при нормальном завершении
+ * (resolve/reject) teardown не абортит, чтобы не влиять на внутреннее состояние endpoint'а.
+ *
+ * @example
+ * ```ts
+ * import { fromRequest } from 'synapse-storage/reactive'
+ *
+ * // Вместо:
+ * from(getList.request({ limit: 20, offset: 0 }))
+ *
+ * // Используйте:
+ * fromRequest(getList.request({ limit: 20, offset: 0 }))
+ *
+ * // В эффекте с validateMap:
+ * apiCall: ([_action, _state, { pageSize }]) =>
+ *   fromRequest(getList.request({ limit: pageSize, offset: 0 })).pipe(
+ *     apiResult((data) => {
+ *       dispatcher.dispatch.applyList(data)
+ *     }),
+ *   ),
+ * ```
+ */ function fromRequest(req) {
+    return new Observable((subscriber)=>{
+        let settled = false;
+        req.wait().then((result)=>{
+            settled = true;
+            if (!subscriber.closed) {
+                subscriber.next(result);
+                subscriber.complete();
+            }
+        }).catch((err)=>{
+            settled = true;
+            if (!subscriber.closed) {
+                subscriber.error(err);
+            }
+        });
+        return ()=>{
+            if (!settled) {
+                req.abort();
+            }
+        };
+    });
+}
+
+export { fromRequest };
+
+//# sourceMappingURL=fromRequest.js.map

package/dist/reactive/effects/utils/fromRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/utils/fromRequest.js","sources":["../../../../src/reactive/effects/utils/fromRequest.ts"],"sourcesContent":["import { Observable } from 'rxjs'\n\nimport type { RequestResponseModify } from '../../../api/types/endpoint.interface'\nimport type { QueryResult } from '../../../api/types/query.interface'\n\n/**\n * Конвертирует `RequestResponseModify` в Observable с поддержкой отмены запроса.\n *\n * **Зачем нужен:**\n * `RequestResponseModify` — thenable-объект (имеет `.then()`), поэтому RxJS `from()`\n * может конвертировать его в Observable напрямую. Однако при таком подходе теряется\n * возможность отмены: когда RxJS отписывается от Observable (switchMap, takeUntil,\n * unsubscribe), Promise продолжает висеть — HTTP-запрос не абортится.\n *\n * `fromRequest` создаёт Observable с teardown-функцией, которая вызывает `req.abort()`\n * при отписке. Это гарантирует, что при переключении на новый запрос (switchMap)\n * или остановке эффектов предыдущий HTTP-запрос будет реально отменён.\n *\n * Abort вызывается только если запрос ещё не завершился — при нормальном завершении\n * (resolve/reject) teardown не абортит, чтобы не влиять на внутреннее состояние endpoint'а.\n *\n * @example\n * ```ts\n * import { fromRequest } from 'synapse-storage/reactive'\n *\n * // Вместо:\n * from(getList.request({ limit: 20, offset: 0 }))\n *\n * // Используйте:\n * fromRequest(getList.request({ limit: 20, offset: 0 }))\n *\n * // В эффекте с validateMap:\n * apiCall: ([_action, _state, { pageSize }]) =>\n *   fromRequest(getList.request({ limit: pageSize, offset: 0 })).pipe(\n *     apiResult((data) => {\n *       dispatcher.dispatch.applyList(data)\n *     }),\n *   ),\n * ```\n */\nexport function fromRequest<T>(req: RequestResponseModify<T>): Observable<QueryResult<T, Error>> {\n  return new Observable((subscriber) => {\n    let settled = false\n\n    req\n      .wait()\n      .then((result) => {\n        settled = true\n        if (!subscriber.closed) {\n          subscriber.next(result)\n          subscriber.complete()\n        }\n      })\n      .catch((err) => {\n        settled = true\n        if (!subscriber.closed) {\n          subscriber.error(err)\n        }\n      })\n\n    return () => {\n      if (!settled) {\n        req.abort()\n      }\n    }\n  })\n}\n"],"names":["Observable","fromRequest","req","subscriber","settled","result","err"],"mappings":";;;AAAiC;AAKjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCC,GACM,SAASC,WAAWA,CAAIC,GAA6B;IAC1D,OAAO,IAAIF,UAAUA,CAAC,CAACG;QACrB,IAAIC,UAAU;QAEdF,IACG,IAAI,GACJ,IAAI,CAAC,CAACG;YACLD,UAAU;YACV,IAAI,CAACD,WAAW,MAAM,EAAE;gBACtBA,WAAW,IAAI,CAACE;gBAChBF,WAAW,QAAQ;YACrB;QACF,GACC,KAAK,CAAC,CAACG;YACNF,UAAU;YACV,IAAI,CAACD,WAAW,MAAM,EAAE;gBACtBA,WAAW,KAAK,CAACG;YACnB;QACF;QAEF,OAAO;YACL,IAAI,CAACF,SAAS;gBACZF,IAAI,KAAK;YACX;QACF;IACF;AACF"}

package/dist/reactive/effects/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './chunkRequestConsistent';
+export * from './chunkRequestParallel';
+export * from './fromRequest';
+export * from './toObservable';
+//# sourceMappingURL=index.d.ts.map

package/dist/reactive/effects/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/reactive/effects/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA"}

package/dist/reactive/effects/utils/index.js

@@ -0,0 +1,11 @@
+export * from "./chunkRequestConsistent.js";
+export * from "./chunkRequestParallel.js";
+export * from "./fromRequest.js";
+export * from "./toObservable.js";
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map

package/dist/reactive/effects/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/utils/index.js","sources":["../../../../src/reactive/effects/utils/index.ts"],"sourcesContent":["export * from './chunkRequestConsistent'\nexport * from './chunkRequestParallel'\nexport * from './fromRequest'\nexport * from './toObservable'\n"],"names":[],"mappings":";;;;AAAwC;AACF;AACT;AACC"}

package/dist/reactive/effects/utils/toObservable.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+import { IStorageBase } from '../../../core';
+/**
+ * Конвертирует хранилище (IStorageBase) в Observable потока состояния.
+ *
+ * @example
+ * ```ts
+ * import { toObservable } from 'synapse-storage/reactive'
+ *
+ * const auth$ = toObservable(authStorage)
+ *
+ * // Использование в createEffectConfig
+ * createEffectConfig: () => ({
+ *   externalStates: { auth: auth$ },
+ * })
+ * ```
+ */
+export declare function toObservable<T extends Record<string, any>>(storage: IStorageBase<T>): Observable<T>;
+/**
+ * Проверяет, является ли значение хранилищем (IStorageBase)
+ */
+export declare function isStorage(value: any): value is IStorageBase<any>;
+//# sourceMappingURL=toObservable.d.ts.map

package/dist/reactive/effects/utils/toObservable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toObservable.d.ts","sourceRoot":"","sources":["../../../../src/reactive/effects/utils/toObservable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAGjC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAUnG;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,YAAY,CAAC,GAAG,CAAC,CAEhE"}

package/dist/reactive/effects/utils/toObservable.js

@@ -0,0 +1,39 @@
+import { Observable } from "rxjs";
+import { shareReplay } from "rxjs/operators";
+
+
+
+
+
+/**
+ * Конвертирует хранилище (IStorageBase) в Observable потока состояния.
+ *
+ * @example
+ * ```ts
+ * import { toObservable } from 'synapse-storage/reactive'
+ *
+ * const auth$ = toObservable(authStorage)
+ *
+ * // Использование в createEffectConfig
+ * createEffectConfig: () => ({
+ *   externalStates: { auth: auth$ },
+ * })
+ * ```
+ */ function toObservable(storage) {
+    return new Observable((observer)=>{
+        observer.next(storage.getStateSync());
+        const unsubscribe = storage.subscribeToAll(()=>{
+            observer.next(storage.getStateSync());
+        });
+        return ()=>unsubscribe();
+    }).pipe(shareReplay(1));
+}
+/**
+ * Проверяет, является ли значение хранилищем (IStorageBase)
+ */ function isStorage(value) {
+    return value && typeof value === 'object' && typeof value.subscribeToAll === 'function' && typeof value.getState === 'function';
+}
+
+export { isStorage, toObservable };
+
+//# sourceMappingURL=toObservable.js.map

package/dist/reactive/effects/utils/toObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/effects/utils/toObservable.js","sources":["../../../../src/reactive/effects/utils/toObservable.ts"],"sourcesContent":["import { Observable } from 'rxjs'\nimport { shareReplay } from 'rxjs/operators'\n\nimport { IStorageBase } from '../../../core'\n\n/**\n * Конвертирует хранилище (IStorageBase) в Observable потока состояния.\n *\n * @example\n * ```ts\n * import { toObservable } from 'synapse-storage/reactive'\n *\n * const auth$ = toObservable(authStorage)\n *\n * // Использование в createEffectConfig\n * createEffectConfig: () => ({\n *   externalStates: { auth: auth$ },\n * })\n * ```\n */\nexport function toObservable<T extends Record<string, any>>(storage: IStorageBase<T>): Observable<T> {\n  return new Observable<T>((observer) => {\n    observer.next(storage.getStateSync())\n\n    const unsubscribe = storage.subscribeToAll(() => {\n      observer.next(storage.getStateSync())\n    })\n\n    return () => unsubscribe()\n  }).pipe(shareReplay(1))\n}\n\n/**\n * Проверяет, является ли значение хранилищем (IStorageBase)\n */\nexport function isStorage(value: any): value is IStorageBase<any> {\n  return value && typeof value === 'object' && typeof value.subscribeToAll === 'function' && typeof value.getState === 'function'\n}\n"],"names":["Observable","shareReplay","toObservable","storage","observer","unsubscribe","isStorage","value"],"mappings":";;;;;AAAiC;AACW;AAI5C;;;;;;;;;;;;;;CAcC,GACM,SAASE,YAAYA,CAAgCC,OAAwB;IAClF,OAAO,IAAIH,UAAUA,CAAI,CAACI;QACxBA,SAAS,IAAI,CAACD,QAAQ,YAAY;QAElC,MAAME,cAAcF,QAAQ,cAAc,CAAC;YACzCC,SAAS,IAAI,CAACD,QAAQ,YAAY;QACpC;QAEA,OAAO,IAAME;IACf,GAAG,IAAI,CAACJ,WAAWA,CAAC;AACtB;AAEA;;CAEC,GACM,SAASK,SAASA,CAACC,KAAU;IAClC,OAAOA,SAAS,OAAOA,UAAU,YAAY,OAAOA,MAAM,cAAc,KAAK,cAAc,OAAOA,MAAM,QAAQ,KAAK;AACvH"}

package/dist/reactive/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dispatcher';
+export * from './effects';
+//# sourceMappingURL=index.d.ts.map

package/dist/reactive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA"}

package/dist/reactive/index.js

@@ -0,0 +1,7 @@
+export * from "./dispatcher/index.js";
+export * from "./effects/index.js";
+
+
+
+
+//# sourceMappingURL=index.js.map

package/dist/reactive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive/index.js","sources":["../../src/reactive/index.ts"],"sourcesContent":["export * from './dispatcher'\nexport * from './effects'\n"],"names":[],"mappings":";;AAA4B;AACH"}

package/dist/utils/createEventBus.d.ts

@@ -0,0 +1,87 @@
+import { IStorage } from '../core';
+export interface EventBusEvent {
+    id: string;
+    event: string;
+    data: any;
+    metadata: {
+        ttl?: number | null;
+        priority?: 'low' | 'normal' | 'high';
+        [key: string]: any;
+    };
+    timestamp: number;
+}
+export interface EventBusState {
+    events: Record<string, EventBusEvent>;
+    subscriptions: Record<string, any>;
+}
+export interface EventBusConfig {
+    name?: string;
+    autoCleanup?: boolean;
+    maxEvents?: number;
+}
+/**
+ * Создает EventBus для связи между модулями
+ *
+ * @example
+ * ```typescript
+ * // Создание EventBus
+ * const eventBus = await createEventBus({
+ *   name: 'app-events',
+ *   autoCleanup: true,
+ *   maxEvents: 500
+ * })
+ *
+ * // Использование в Synapse
+ * const mySynapse = await createSynapse({
+ *   dependencies: [eventBus],
+ *   createEffectConfig: () => ({
+ *     externalDispatchers: {
+ *       eventBus: eventBus.dispatcher
+ *     }
+ *   }),
+ *   effects: [
+ *     createEffect((action$, _, { dispatcher, externalDispatchers: { eventBus } }) => {
+ *       // Публикация события
+ *       eventBus.dispatch.publish({
+ *         event: 'USER_UPDATED',
+ *         data: { userId: 123 }
+ *       })
+ *
+ *       // Подписка на события
+ *       eventBus.dispatch.subscribe({
+ *         eventPattern: 'CORE_*',
+ *         handler: (data, event) => console.log('Received:', event.event, data)
+ *       })
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+export declare const createEventBus: (config?: EventBusConfig) => Promise<import("./createSynapse").SynapseStoreWithDispatcher<EventBusState, IStorage<EventBusState>, any, Record<string, import("..").DispatchFunction<any, any>> & import("..").DispatchActions<{
+    publish: import("..").DispatchFunction<{
+        event: string;
+        data: any;
+        metadata?: Record<string, any>;
+    }, {
+        eventId: string;
+        event: string;
+        data: any;
+    }>;
+    subscribe: import("..").DispatchFunction<{
+        eventPattern: string;
+        handler: (data: any, event: EventBusEvent) => void | Promise<void>;
+        options?: Record<string, any>;
+    }, {
+        subscriptionId: string;
+        unsubscribe: () => void;
+    }>;
+    getEventHistory: import("..").DispatchFunction<{
+        eventType: string;
+        limit?: number;
+    }, EventBusEvent[]>;
+    clearEvents: import("..").DispatchFunction<{
+        olderThan?: number;
+    } | undefined, void>;
+    getActiveSubscriptions: import("..").DispatchFunction<any, any[]>;
+}>>>;
+//# sourceMappingURL=createEventBus.d.ts.map

package/dist/utils/createEventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEventBus.d.ts","sourceRoot":"","sources":["../../src/utils/createEventBus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAA+B,MAAM,SAAS,CAAA;AAI/D,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,GAAG,CAAA;IACT,QAAQ,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAA;QACpC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,CAAA;IACD,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACrC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,cAAmB;;eAuBE,MAAM;cAAQ,GAAG;mBAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;;sBAiCnF,MAAM;iBACX,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;kBACxD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;mBAgDmB,MAAM;gBAAU,MAAM;;;oBAalC,MAAM;;;IAqClD,CAAA"}