synapse-storage 3.0.1 → 3.0.3

package/dist/dispatcher.module-CdpmkplA.d.cts

@@ -0,0 +1,363 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { I as IStorage } from './storage.interface-Dl8SLUd1.cjs';
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПОСЛЕДОВАТЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+declare const chunkRequestConsistent: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+type ChunkRequestConsistent = typeof chunkRequestConsistent;
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПАРАЛЛЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+declare const chunkRequestParallel: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+type ChunkRequestParallel = typeof chunkRequestParallel;
+
+/**
+ * Тип действия с типизированным payload
+ */
+interface TypedAction<P> extends Action<P> {
+    type: string;
+    payload: P;
+}
+/**
+ * Тип для внешних состояний
+ */
+type ExternalStates = Record<string, Observable<any>>;
+/**
+ * Тип для базового эффекта без доступа к состоянию
+ */
+type EffectBase<TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>> = (action$: Observable<Action>, dispatchers: TDispatchers, services: TServices) => Observable<unknown>;
+/**
+ * Тип для эффекта с доступом к состоянию и конфигурации - это основной тип, который используется по умолчанию
+ */
+type Effect<TState extends Record<string, any> = any, TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> = (action$: Observable<Action>, state$: Observable<TState>, externalStates: TExternalStates, dispatchers: TDispatchers, services: TServices, config: TConfig) => Observable<unknown>;
+/**
+ * Тип для получения типов действий диспетчера
+ */
+type DispatcherActions<T> = T extends Dispatcher<any, infer A> ? ActionsResult<A> : Record<string, DispatchFunction<any, any>>;
+/**
+ * Конфигурация для валидации в validateMap
+ */
+interface ValidateConfig {
+    conditions: boolean[];
+    skipAction: (() => any) | any | ((() => any) | any)[];
+}
+/**
+ * Утилиты для запросов в validateMap
+ */
+interface ValidateMapRequestUtils {
+    chunkRequest: ChunkRequestParallel;
+    chunkRequestConsistent: ChunkRequestConsistent;
+}
+/**
+ * Оператор для фильтрации действий по типу с сохранением типа payload
+ */
+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 Массив функций действий
+ */
+declare function ofTypes<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): OperatorFunction<Action, TypedAction<ExtractResultType<T[number]>>>;
+/**
+ * Оператор для ожидания выполнения всех указанных действий
+ * @param actionFns Массив функций действий
+ */
+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 с массивом выбранных значений
+ */
+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 с объектом выбранных значений
+ */
+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
+ */
+declare function validateMap<T, TResult = any>({ validator, apiCall, }: {
+    validator?: (value: T) => ValidateConfig;
+    apiCall: (value: T, utils: ValidateMapRequestUtils) => Observable<TResult>;
+}): OperatorFunction<T, any>;
+/**
+ * Класс для управления эффектами с поддержкой доступа к состоянию и конфигурации
+ * Основной класс, который следует использовать
+ */
+declare class EffectsModule<TState extends Record<string, any> = any, TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> {
+    private storage;
+    private externalStates;
+    private dispatchers;
+    private services;
+    private config;
+    private effects;
+    private subscriptions;
+    private running;
+    private action$;
+    /**
+     * Поток состояния
+     */
+    readonly state$: Observable<TState>;
+    /**
+     * Создает модуль эффектов с доступом к состоянию, внешним состояниям и конфигурации
+     * @param storage Хранилище состояния
+     * @param externalStates Внешние состояния
+     * @param dispatchers Объект с диспетчерами
+     * @param services Объект с сервисами
+     * @param config Глобальная конфигурация для всех эффектов
+     */
+    constructor(storage: IStorage<TState>, externalStates: TExternalStates | undefined, dispatchers: TDispatchers, services?: TServices, config?: TConfig);
+    /**
+     * Подписывается на действия от всех диспетчеров
+     */
+    private subscribeToDispatchers;
+    add(effect: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>): this;
+    /**
+     * Добавляет несколько эффектов
+     * @param effects Эффекты для добавления
+     * @returns Текущий модуль
+     */
+    addEffects(effects: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>[]): this;
+    /**
+     * Запускает все эффекты
+     * @returns Текущий модуль
+     */
+    start(): this;
+    /**
+     * Останавливает все эффекты
+     * @returns Текущий модуль
+     */
+    stop(): this;
+    /**
+     * Подписывается на конкретный эффект
+     * @param effect Эффект для подписки
+     */
+    private subscribeToEffect;
+}
+/**
+ * Вспомогательная функция для создания типизированного эффекта без состояния
+ * @deprecated Используйте createEffect вместо этого
+ */
+declare function createEffectBase<TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>>(effect: EffectBase<TDispatchers, TServices>): EffectBase<TDispatchers, TServices>;
+/**
+ * Вспомогательная функция для создания типизированного эффекта с состоянием и конфигурацией
+ */
+declare function createEffect<TState extends Record<string, any>, TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(effect: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>): Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>;
+/**
+ * Объединяет несколько эффектов в один
+ * @param effects Эффекты для объединения
+ * @returns Объединенный эффект
+ */
+declare function combineEffects<TState extends Record<string, any>, TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(...effects: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>[]): Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>;
+
+/**
+ * Расширенное API для middleware
+ */
+interface EnhancedMiddlewareAPI<T extends Record<string, any>> {
+    getState: () => Promise<T>;
+    dispatch: (action: Action) => Promise<any>;
+    storage: IStorage<T>;
+    actions$: Observable<Action>;
+    actions: Record<string, DispatchFunction<any, any>>;
+    watchers: Record<string, WatcherFunction<any>>;
+    findActionByType: (actionType: string) => DispatchFunction<any, any> | undefined;
+    findWatcherByType: (actionType: string) => WatcherFunction<any> | undefined;
+}
+/**
+ * Расширенное определение middleware
+ */
+interface EnhancedMiddleware<T extends Record<string, any> = any> {
+    (api: EnhancedMiddlewareAPI<T>): (next: (action: Action) => Promise<any>) => (action: Action) => Promise<any>;
+}
+/**
+ * Базовая структура действия
+ */
+interface Action<T = unknown> {
+    type: string;
+    payload?: T;
+    meta?: Record<string, any>;
+}
+interface ActionExecutionOptions {
+    worker?: Worker;
+    memoize?: (currentArgs: any[], previousArgs: any[], previousResult: any) => boolean;
+}
+/**
+ * Параметры для создания действия
+ */
+interface ActionDefinition<TParams, TResult> {
+    /** Тип действия для идентификации в потоке и эффектах */
+    type: string;
+    /** Функция, выполняющая действие и возвращающая результат (payload) */
+    action: (params: TParams) => Promise<TResult> | TResult;
+    /** Дополнительные метаданные (опционально) */
+    meta?: Record<string, any>;
+}
+/**
+ * Определение типа для watcher'а
+ */
+interface WatcherDefinition<T, R> {
+    type: string;
+    selector: (state: T) => R;
+    meta?: Record<string, any>;
+    shouldTrigger?: (prev: R | undefined, current: R) => boolean;
+}
+/**
+ * Тип для функции watcher
+ */
+interface WatcherFunction<R> {
+    (): Observable<TypedAction<R>>;
+    actionType: string;
+    meta?: Record<string, any>;
+    unsubscribe: VoidFunction;
+}
+/**
+ * Расширенный тип для функции настройки действий с поддержкой дополнительных утилит
+ */
+type ActionsSetupWithUtils<T extends Record<string, unknown>> = (storage: IStorage<T>, utils: {
+    createAction: ActionCreatorFactory;
+    createWatcher: <R>(config: WatcherDefinition<T, R>) => WatcherFunction<R>;
+}) => Record<string, DispatchFunction<any, any> | WatcherFunction<any>>;
+/**
+ * Расширенная функция диспетчеризации
+ */
+interface DispatchFunction<TParams, TResult> {
+    /** Функция для вызова действия с параметрами */
+    (params: TParams): Promise<TResult>;
+    /** Тип действия для использования в эффектах */
+    actionType: string;
+    /** Метаданные действия */
+    meta?: Record<string, any>;
+    /** Внутренний тип для идентификации */
+    _type?: 'dispatch' | 'watchers';
+}
+/**
+ * Тип для фабрики создателей действий
+ */
+type ActionCreatorFactory = <TParams, TResult>(config: ActionDefinition<TParams, TResult>, executionOptions?: ActionExecutionOptions) => DispatchFunction<TParams, TResult>;
+/**
+ * Тип для функции настройки действий
+ */
+type ActionsSetup<T extends Record<string, unknown>> = (create: ActionCreatorFactory, storage: IStorage<T>) => Record<string, DispatchFunction<any, any>>;
+/**
+ * Извлекает тип результата из функции диспетчера
+ */
+type ExtractResultType<T> = T extends DispatchFunction<any, infer R> ? R : never;
+/**
+ * Извлекает типы из функции настройки действий
+ */
+type ActionsResult<F> = F extends (create: ActionCreatorFactory, storage: any, ...args: any[]) => infer R ? R : Record<string, DispatchFunction<any, any>>;
+/**
+ * Типизированный объект действий
+ */
+type DispatchActions<T> = {
+    [K in keyof T]: T[K] extends DispatchFunction<any, any> ? T[K] : never;
+};
+/**
+ * Типизированный объект watchers
+ */
+type WatcherActions<T> = {
+    [K in keyof T]: T[K] extends WatcherFunction<any> ? T[K] : never;
+};
+/**
+ * Параметры для Dispatcher
+ */
+interface DispatcherOptions<T extends Record<string, any>> {
+    storage: IStorage<T>;
+    worker?: Worker;
+    middlewares?: EnhancedMiddleware<T>[];
+}
+/**
+ * Интерфейс для API middleware
+ */
+interface DispatcherMiddlewareAPI<T extends Record<string, any>> {
+    getState: () => Promise<T>;
+    dispatch: (action: Action) => Promise<any>;
+}
+/**
+ * Интерфейс для middleware
+ */
+interface DispatcherMiddleware<T extends Record<string, any> = any> {
+    (api: DispatcherMiddlewareAPI<T>): (next: (action: Action) => Promise<any>) => (action: Action) => Promise<any>;
+}
+/**
+ * Класс Dispatcher для интеграции хранилищ с реактивной системой
+ */
+declare class Dispatcher<T extends Record<string, any>, TActionsFn extends ActionsSetupWithUtils<T> = ActionsSetupWithUtils<T>> {
+    private options;
+    private actions$;
+    readonly actions: Observable<Action>;
+    dispatch: Record<string, DispatchFunction<any, any>>;
+    watchers: Record<string, WatcherFunction<any>>;
+    private storage;
+    private middlewareFunctions;
+    private middlewareAPI;
+    /**
+     * Создает новый экземпляр Dispatcher
+     */
+    constructor(options: DispatcherOptions<T>);
+    /**
+     * Добавляет middleware в цепочку обработки
+     */
+    use(...middlewares: EnhancedMiddleware<T>[]): this;
+    /**
+     * Получает все действия с улучшенной типизацией
+     */
+    getActions(): ActionsResult<TActionsFn>;
+    /**
+     * Получает типизированные действия диспетчера
+     */
+    getTypedDispatch<A extends Record<string, any>>(): DispatchActions<A>;
+    /**
+     * Получает типизированные watcher'ы
+     */
+    getTypedWatchers<A extends Record<string, any>>(): WatcherActions<A>;
+    /**
+     * Находит действие по типу
+     */
+    findActionByType(actionType: string): DispatchFunction<any, any> | undefined;
+    /**
+     * Находит наблюдатель по типу
+     */
+    findWatcherByType(actionType: string): WatcherFunction<any> | undefined;
+    /**
+     * Создает действие
+     */
+    createAction<TParams, TResult>(actionConfig: ActionDefinition<TParams, TResult>, executionOptions?: ActionExecutionOptions): DispatchFunction<TParams, TResult>;
+    /**
+     * Создает watcher для отслеживания изменений в хранилище
+     */
+    createWatcher<R>(config: WatcherDefinition<T, R>): WatcherFunction<R>;
+    /**
+     * Выполняет действие в worker
+     */
+    private executeInWorker;
+}
+/**
+ * Функция для создания типизированного диспетчера
+ */
+declare function createDispatcher<TState extends Record<string, any>, TActions extends ActionsSetupWithUtils<TState>>(options: DispatcherOptions<TState>, actionsSetup: TActions): Dispatcher<TState, TActions> & {
+    dispatch: DispatchActions<ReturnType<TActions>>;
+    watchers: WatcherActions<ReturnType<TActions>>;
+};
+type CreateDispatcherType = ReturnType<typeof createDispatcher>;
+
+export { type Action as A, combineEffects as B, type CreateDispatcherType as C, type DispatchFunction as D, type EnhancedMiddlewareAPI as E, type TypedAction as T, type ValidateConfig as V, type WatcherFunction as W, type EnhancedMiddleware as a, type ActionDefinition as b, type ActionsSetupWithUtils as c, type ActionsSetup as d, type ExtractResultType as e, type ActionsResult as f, type DispatchActions as g, type WatcherActions as h, type DispatcherMiddlewareAPI as i, type DispatcherMiddleware as j, Dispatcher as k, createDispatcher as l, type ExternalStates as m, type EffectBase as n, type Effect as o, type DispatcherActions as p, type ValidateMapRequestUtils as q, ofType as r, ofTypes as s, ofTypesWaitAll as t, selectorMap as u, selectorObject as v, validateMap as w, EffectsModule as x, createEffectBase as y, createEffect as z };