synapse-storage 3.0.2 → 3.0.4

package/dist/reactive.d.ts

@@ -0,0 +1,35 @@
+import { a as EnhancedMiddleware } from './dispatcher.module-jd8U_ZEs.js';
+export { A as Action, b as ActionDefinition, f as ActionsResult, d as ActionsSetup, c as ActionsSetupWithUtils, C as CreateDispatcherType, g as DispatchActions, D as DispatchFunction, k as Dispatcher, p as DispatcherActions, j as DispatcherMiddleware, i as DispatcherMiddlewareAPI, o as Effect, n as EffectBase, x as EffectsModule, E as EnhancedMiddlewareAPI, m as ExternalStates, e as ExtractResultType, T as TypedAction, V as ValidateConfig, q as ValidateMapRequestUtils, h as WatcherActions, W as WatcherFunction, B as combineEffects, l as createDispatcher, z as createEffect, y as createEffectBase, r as ofType, s as ofTypes, t as ofTypesWaitAll, u as selectorMap, v as selectorObject, w as validateMap } from './dispatcher.module-jd8U_ZEs.js';
+import 'rxjs';
+import './storage.interface-Dl8SLUd1.js';
+
+interface LoggerTranslations {
+    action: string;
+    prevState: string;
+    nextState: string;
+    duration: string;
+    error: string;
+    diff: string;
+    changesCount: string;
+    showFullState: string;
+}
+interface LoggerColors {
+    title: string;
+    prevState: string;
+    fullState: string;
+    action: string;
+    nextState: string;
+    error: string;
+    diff: string;
+}
+interface LoggerOptions {
+    collapsed?: boolean;
+    duration?: boolean;
+    diff?: boolean;
+    showFullState?: boolean;
+    translations?: Partial<LoggerTranslations>;
+    colors?: Partial<LoggerColors>;
+}
+declare const loggerDispatcherMiddleware: <State extends Record<string, any>>(options?: LoggerOptions) => EnhancedMiddleware<State>;
+
+export { EnhancedMiddleware, loggerDispatcherMiddleware };

package/dist/reactive.js

@@ -0,0 +1 @@
+export{a as Dispatcher,j as EffectsModule,m as combineEffects,b as createDispatcher,l as createEffect,k as createEffectBase,c as loggerDispatcherMiddleware,d as ofType,e as ofTypes,f as ofTypesWaitAll,g as selectorMap,h as selectorObject,i as validateMap}from'./chunk-IPUPRMZK.js';import'./chunk-5X65PSGD.js';

package/dist/{core/selector/selector.interface.d.ts → selector.interface-CA5y-kD_.d.cts}

@@ -1,14 +1,14 @@
-export interface Selector<T, R> {
+interface Selector<T, R> {
     (state: T): R;
 }
-export interface SelectorOptions<T> {
+interface SelectorOptions<T> {
     equals?: (a: T, b: T) => boolean;
     name?: string;
 }
-export interface Subscriber<T> {
+interface Subscriber<T> {
     notify: (value: T) => void | Promise<void>;
 }
-export interface SelectorAPI<T> {
+interface SelectorAPI<T> {
     select: () => Promise<T>;
     subscribe: (subscriber: Subscriber<T>) => VoidFunction;
     getId: () => string;
@@ -17,7 +17,7 @@ export interface SelectorAPI<T> {
  * Интерфейс для модуля селекторов
  * Определяет контракт для работы с селекторами, который должен реализовывать SelectorModule
  */
-export interface ISelectorModule<TStore extends Record<string, any>> {
+interface ISelectorModule<TStore extends Record<string, any>> {
     /**
      * Имя связанного хранилища
      */
@@ -59,33 +59,5 @@ export interface ISelectorModule<TStore extends Record<string, any>> {
      */
     destroy(): void;
 }
-/**
- * Интерфейс для фабрики селекторов
- * Позволяет создавать набор связанных селекторов
- */
-export interface ISelectorCreator<TStore extends Record<string, any>, TSelectors, TExternalSelectors = Record<string, any>> {
-    /**
-     * Создает набор селекторов
-     *
-     * @param selectorModule Модуль селекторов
-     * @param externalSelectors Внешние селекторы (опционально)
-     * @returns Объект с селекторами
-     *
-     * @example
-     * const createUserSelectors: ISelectorCreator<UserStore, UserSelectors> =
-     *   (selectorModule, externalSelectors) => {
-     *     const isActive = selectorModule.createSelector(
-     *       (state) => state.user.isActive
-     *     );
-     *
-     *     return { isActive };
-     *   };
-     */
-    (selectorModule: ISelectorModule<TStore>, externalSelectors?: TExternalSelectors): TSelectors;
-}
-/**
- * Тип для функции, создающей селекторы
- * Более простая версия ISelectorCreator, если не нужен полный интерфейс
- */
-export type SelectorCreatorFunction<TStore extends Record<string, any> = Record<string, any>, TSelectors = any, TExternalSelectors = Record<string, any>> = (selectorModule: ISelectorModule<TStore>, externalSelectors?: TExternalSelectors) => TSelectors;
-//# sourceMappingURL=selector.interface.d.ts.map
+
+export type { ISelectorModule as I, SelectorAPI as S, Selector as a, SelectorOptions as b };

package/dist/selector.interface-CA5y-kD_.d.ts

@@ -0,0 +1,63 @@
+interface Selector<T, R> {
+    (state: T): R;
+}
+interface SelectorOptions<T> {
+    equals?: (a: T, b: T) => boolean;
+    name?: string;
+}
+interface Subscriber<T> {
+    notify: (value: T) => void | Promise<void>;
+}
+interface SelectorAPI<T> {
+    select: () => Promise<T>;
+    subscribe: (subscriber: Subscriber<T>) => VoidFunction;
+    getId: () => string;
+}
+/**
+ * Интерфейс для модуля селекторов
+ * Определяет контракт для работы с селекторами, который должен реализовывать SelectorModule
+ */
+interface ISelectorModule<TStore extends Record<string, any>> {
+    /**
+     * Имя связанного хранилища
+     */
+    readonly storageName: string;
+    /**
+     * Создает простой селектор на основе функции выбора
+     *
+     * @param selector Функция, извлекающая данные из состояния
+     * @param options Опции селектора
+     * @returns API селектора
+     *
+     * @example
+     * const isActive = selectorModule.createSelector(
+     *   (state) => state.user.isActive,
+     *   { name: 'userIsActive' }
+     * );
+     */
+    createSelector<T>(selector: Selector<TStore, T>, options?: SelectorOptions<T>): SelectorAPI<T>;
+    /**
+     * Создает комбинированный селектор на основе других селекторов
+     *
+     * @param dependencies Массив селекторов, от которых зависит новый селектор
+     * @param resultFn Функция, комбинирующая результаты зависимостей
+     * @param options Опции селектора
+     * @returns API селектора
+     *
+     * @example
+     * const userWithStatus = selectorModule.createSelector(
+     *   [userSelector, statusSelector],
+     *   (user, status) => ({ ...user, status }),
+     *   { name: 'userWithStatus' }
+     * );
+     */
+    createSelector<Deps extends unknown[], T>(dependencies: {
+        [K in keyof Deps]: SelectorAPI<Deps[K]>;
+    }, resultFn: (...args: Deps) => T, options?: SelectorOptions<T>): SelectorAPI<T>;
+    /**
+     * Освобождает ресурсы, связанные с модулем селекторов
+     */
+    destroy(): void;
+}
+
+export type { ISelectorModule as I, SelectorAPI as S, Selector as a, SelectorOptions as b };

package/dist/storage.interface-Dl8SLUd1.d.cts

@@ -0,0 +1,128 @@
+declare class StorageKey {
+    private readonly value;
+    private readonly isRawKey;
+    constructor(value: string, isRawKey?: boolean);
+    toString(): string;
+    toJSON(): string;
+    valueOf(): string;
+    isUnparseable(): boolean;
+}
+type StorageKeyType = string | StorageKey;
+
+interface IndexedDBConfig {
+    dbName?: string;
+    dbVersion?: number;
+    storeName?: string;
+}
+
+type StorageActionType = 'get' | 'set' | 'delete' | 'clear' | 'init' | 'keys' | 'update';
+type StorageAction = {
+    type: StorageActionType;
+    key?: StorageKeyType;
+    value?: any;
+    metadata?: Record<string, any>;
+    source?: string;
+    timestamp?: number;
+};
+type MiddlewareAPI = {
+    dispatch: (action: StorageAction) => Promise<any>;
+    getState: () => Promise<Record<string, any>>;
+    storage: {
+        doGet: (key: StorageKeyType) => Promise<any>;
+        doSet: (key: StorageKeyType, value: any) => Promise<void>;
+        doUpdate: (updates: Array<{
+            key: StorageKeyType;
+            value: any;
+        }>) => Promise<void>;
+        doDelete: (key: StorageKeyType) => Promise<boolean>;
+        doClear: () => Promise<void>;
+        doKeys: () => Promise<string[]>;
+        notifySubscribers: (key: StorageKeyType, value: any) => void;
+    };
+};
+type NextFunction = (action: StorageAction) => Promise<any>;
+type SetupEventsFunction = (api: MiddlewareAPI) => void;
+type Middleware = {
+    name: string;
+    setup?: SetupEventsFunction;
+    cleanup?: () => Promise<void> | void;
+    reducer: (api: MiddlewareAPI) => (next: NextFunction) => (action: StorageAction) => Promise<any>;
+};
+
+interface BatchingMiddlewareOptions {
+    batchSize?: number;
+    batchDelay?: number;
+}
+
+interface ShallowCompareMiddlewareOptions {
+    segments?: string[];
+    comparator?: <T>(prev: T, next: T) => boolean;
+}
+
+interface IStorage<T extends Record<string, any> = any> {
+    name: string;
+    get<R>(key: StorageKeyType): Promise<R | undefined>;
+    getState(): Promise<T>;
+    set<R>(key: StorageKeyType, value: R): Promise<void>;
+    update(updater: (state: T) => void): Promise<void>;
+    has(key: StorageKeyType): Promise<boolean>;
+    delete(key: StorageKeyType): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    destroy(): Promise<void>;
+    subscribeToAll(callback: (event: {
+        type: string;
+        changedPaths?: string[];
+        key?: StorageKeyType[] | StorageKeyType;
+        value?: any;
+    }) => void): VoidFunction;
+    initialize(): Promise<this>;
+    subscribe(key: StorageKeyType, callback: (value: any) => void): VoidFunction;
+    subscribe<R>(pathSelector: (state: T) => R, callback: (value: R) => void): VoidFunction;
+}
+declare enum StorageEvents {
+    STORAGE_UPDATE = "storage:update",
+    STORAGE_DELETE = "storage:delete",
+    STORAGE_PATCH = "storage:patch",
+    STORAGE_SELECT = "storage:select",
+    STORAGE_CLEAR = "storage:clear",
+    STORAGE_DESTROY = "storage:destroy"
+}
+interface StorageEvent<T = any> {
+    type: string;
+    payload?: T;
+    metadata?: Record<string, any>;
+}
+interface IEventEmitter {
+    emit(event: StorageEvent): Promise<void>;
+}
+interface ILogger {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+interface DefaultMiddlewares {
+    batching: (options?: BatchingMiddlewareOptions) => Middleware;
+    shallowCompare: (options?: ShallowCompareMiddlewareOptions) => Middleware;
+}
+type GetDefaultMiddleware = () => DefaultMiddlewares;
+type ConfigureMiddlewares = (getDefaultMiddleware: GetDefaultMiddleware) => Middleware[];
+interface StorageConfig {
+    name: string;
+    initialState?: Record<string, any>;
+    middlewares?: ConfigureMiddlewares;
+}
+type StorageType = 'memory' | 'localStorage' | 'indexedDB';
+interface MemoryStorageConfig extends StorageConfig {
+    type: 'memory';
+}
+interface LocalStorageConfig extends StorageConfig {
+    type: 'localStorage';
+}
+interface IndexedDBStorageConfig extends StorageConfig {
+    type: 'indexedDB';
+    options: IndexedDBConfig;
+}
+
+export { type BatchingMiddlewareOptions as B, type ConfigureMiddlewares as C, type DefaultMiddlewares as D, type GetDefaultMiddleware as G, type IStorage as I, type LocalStorageConfig as L, type Middleware as M, type NextFunction as N, type ShallowCompareMiddlewareOptions as S, type MiddlewareAPI as a, type StorageAction as b, type StorageKeyType as c, StorageEvents as d, type StorageEvent as e, type IEventEmitter as f, type ILogger as g, type StorageConfig as h, type StorageType as i, type MemoryStorageConfig as j, type IndexedDBStorageConfig as k, StorageKey as l };

package/dist/storage.interface-Dl8SLUd1.d.ts

@@ -0,0 +1,128 @@
+declare class StorageKey {
+    private readonly value;
+    private readonly isRawKey;
+    constructor(value: string, isRawKey?: boolean);
+    toString(): string;
+    toJSON(): string;
+    valueOf(): string;
+    isUnparseable(): boolean;
+}
+type StorageKeyType = string | StorageKey;
+
+interface IndexedDBConfig {
+    dbName?: string;
+    dbVersion?: number;
+    storeName?: string;
+}
+
+type StorageActionType = 'get' | 'set' | 'delete' | 'clear' | 'init' | 'keys' | 'update';
+type StorageAction = {
+    type: StorageActionType;
+    key?: StorageKeyType;
+    value?: any;
+    metadata?: Record<string, any>;
+    source?: string;
+    timestamp?: number;
+};
+type MiddlewareAPI = {
+    dispatch: (action: StorageAction) => Promise<any>;
+    getState: () => Promise<Record<string, any>>;
+    storage: {
+        doGet: (key: StorageKeyType) => Promise<any>;
+        doSet: (key: StorageKeyType, value: any) => Promise<void>;
+        doUpdate: (updates: Array<{
+            key: StorageKeyType;
+            value: any;
+        }>) => Promise<void>;
+        doDelete: (key: StorageKeyType) => Promise<boolean>;
+        doClear: () => Promise<void>;
+        doKeys: () => Promise<string[]>;
+        notifySubscribers: (key: StorageKeyType, value: any) => void;
+    };
+};
+type NextFunction = (action: StorageAction) => Promise<any>;
+type SetupEventsFunction = (api: MiddlewareAPI) => void;
+type Middleware = {
+    name: string;
+    setup?: SetupEventsFunction;
+    cleanup?: () => Promise<void> | void;
+    reducer: (api: MiddlewareAPI) => (next: NextFunction) => (action: StorageAction) => Promise<any>;
+};
+
+interface BatchingMiddlewareOptions {
+    batchSize?: number;
+    batchDelay?: number;
+}
+
+interface ShallowCompareMiddlewareOptions {
+    segments?: string[];
+    comparator?: <T>(prev: T, next: T) => boolean;
+}
+
+interface IStorage<T extends Record<string, any> = any> {
+    name: string;
+    get<R>(key: StorageKeyType): Promise<R | undefined>;
+    getState(): Promise<T>;
+    set<R>(key: StorageKeyType, value: R): Promise<void>;
+    update(updater: (state: T) => void): Promise<void>;
+    has(key: StorageKeyType): Promise<boolean>;
+    delete(key: StorageKeyType): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    destroy(): Promise<void>;
+    subscribeToAll(callback: (event: {
+        type: string;
+        changedPaths?: string[];
+        key?: StorageKeyType[] | StorageKeyType;
+        value?: any;
+    }) => void): VoidFunction;
+    initialize(): Promise<this>;
+    subscribe(key: StorageKeyType, callback: (value: any) => void): VoidFunction;
+    subscribe<R>(pathSelector: (state: T) => R, callback: (value: R) => void): VoidFunction;
+}
+declare enum StorageEvents {
+    STORAGE_UPDATE = "storage:update",
+    STORAGE_DELETE = "storage:delete",
+    STORAGE_PATCH = "storage:patch",
+    STORAGE_SELECT = "storage:select",
+    STORAGE_CLEAR = "storage:clear",
+    STORAGE_DESTROY = "storage:destroy"
+}
+interface StorageEvent<T = any> {
+    type: string;
+    payload?: T;
+    metadata?: Record<string, any>;
+}
+interface IEventEmitter {
+    emit(event: StorageEvent): Promise<void>;
+}
+interface ILogger {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+interface DefaultMiddlewares {
+    batching: (options?: BatchingMiddlewareOptions) => Middleware;
+    shallowCompare: (options?: ShallowCompareMiddlewareOptions) => Middleware;
+}
+type GetDefaultMiddleware = () => DefaultMiddlewares;
+type ConfigureMiddlewares = (getDefaultMiddleware: GetDefaultMiddleware) => Middleware[];
+interface StorageConfig {
+    name: string;
+    initialState?: Record<string, any>;
+    middlewares?: ConfigureMiddlewares;
+}
+type StorageType = 'memory' | 'localStorage' | 'indexedDB';
+interface MemoryStorageConfig extends StorageConfig {
+    type: 'memory';
+}
+interface LocalStorageConfig extends StorageConfig {
+    type: 'localStorage';
+}
+interface IndexedDBStorageConfig extends StorageConfig {
+    type: 'indexedDB';
+    options: IndexedDBConfig;
+}
+
+export { type BatchingMiddlewareOptions as B, type ConfigureMiddlewares as C, type DefaultMiddlewares as D, type GetDefaultMiddleware as G, type IStorage as I, type LocalStorageConfig as L, type Middleware as M, type NextFunction as N, type ShallowCompareMiddlewareOptions as S, type MiddlewareAPI as a, type StorageAction as b, type StorageKeyType as c, StorageEvents as d, type StorageEvent as e, type IEventEmitter as f, type ILogger as g, type StorageConfig as h, type StorageType as i, type MemoryStorageConfig as j, type IndexedDBStorageConfig as k, StorageKey as l };

package/dist/utils.cjs

@@ -0,0 +1 @@
+'use strict';var chunkWC5TDS6C_cjs=require('./chunk-WC5TDS6C.cjs');require('./chunk-VSIVOWZF.cjs'),require('./chunk-UFBCZ25Y.cjs'),require('./chunk-635Q6YJZ.cjs'),require('./chunk-NMDHQXMS.cjs');Object.defineProperty(exports,"createSynapse",{enumerable:true,get:function(){return chunkWC5TDS6C_cjs.a}});

package/dist/utils.d.cts

@@ -0,0 +1,92 @@
+import { Observable } from 'rxjs';
+import { I as ISelectorModule } from './selector.interface-CA5y-kD_.cjs';
+import { I as IStorage } from './storage.interface-Dl8SLUd1.cjs';
+import { m as ExternalStates, o as Effect } from './dispatcher.module-CdpmkplA.cjs';
+
+type ExtractDispatchType<T> = T extends {
+    dispatch: infer D;
+} ? D : never;
+type StorageCreatorFunction<T extends Record<string, any>> = () => Promise<IStorage<T>>;
+/**
+ * Базовая конфигурация хранилища
+ */
+type BaseSynapseConfig<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = ({
+    storage: IStorage<TStore>;
+    createStorageFn?: undefined;
+} | {
+    storage?: undefined;
+    createStorageFn: StorageCreatorFunction<TStore>;
+}) & {
+    externalSelectors?: TExternalSelectors;
+    createSelectorsFn?: (selectorModule: ISelectorModule<TStore>, externalSelectors: TExternalSelectors) => TSelectors;
+};
+/**
+ * Конфигурация с dispatcher и effects
+ */
+type CreateSynapseConfigWithEffects<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
+    createEffectConfig: (dispatcher: TDispatcher) => {
+        dispatchers: Record<string, any>;
+        api?: TApi;
+        config?: TConfig;
+        externalStates?: ExternalStates;
+    };
+    effects?: Effect<TStore, any, TApi, TConfig, any>[];
+};
+/**
+ * Конфигурация только с dispatcher
+ */
+type CreateSynapseConfigWithDispatcher<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
+    createEffectConfig?: never;
+    effects?: never;
+};
+/**
+ * Конфигурация без dispatcher
+ */
+type CreateSynapseConfigBasic<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn?: never;
+    createEffectConfig?: never;
+    effects?: never;
+};
+/**
+ * Результат с dispatcher и effects
+ */
+interface SynapseStoreWithEffects<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
+    storage: TStorage;
+    selectors: TSelectors;
+    actions: TActions;
+    state$: Observable<TStore>;
+    dispatcher: any;
+    destroy: () => Promise<void>;
+}
+/**
+ * Результат только с dispatcher
+ */
+interface SynapseStoreWithDispatcher<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
+    storage: TStorage;
+    selectors: TSelectors;
+    actions: TActions;
+    dispatcher: any;
+    destroy: () => Promise<void>;
+}
+/**
+ * Результат без dispatcher
+ */
+interface SynapseStoreBasic<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors> {
+    storage: TStorage;
+    selectors: TSelectors;
+    destroy: () => Promise<void>;
+}
+/**
+ * Union-тип для всех возможных результатов createSynapse
+ */
+type AnySynapseStore<TStore extends Record<string, any> = any, TStorage extends IStorage<TStore> = IStorage<any>, TSelectors = any, TActions = any> = SynapseStoreWithEffects<TStore, TStorage, TSelectors, TActions> | SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, TActions> | SynapseStoreBasic<TStore, TStorage, TSelectors>;
+/**
+ * Перегрузки функции createSynapse
+ */
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithEffects<TStore, TSelectors, TDispatcher, TApi, TConfig, TExternalSelectors>): Promise<SynapseStoreWithEffects<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithDispatcher<TStore, TSelectors, TDispatcher, TExternalSelectors>): Promise<SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigBasic<TStore, TSelectors, TExternalSelectors>): Promise<SynapseStoreBasic<TStore, TStorage, TSelectors>>;
+
+export { type AnySynapseStore, type SynapseStoreBasic, type SynapseStoreWithDispatcher, type SynapseStoreWithEffects, createSynapse };

package/dist/utils.d.ts

@@ -0,0 +1,92 @@
+import { Observable } from 'rxjs';
+import { I as ISelectorModule } from './selector.interface-CA5y-kD_.js';
+import { I as IStorage } from './storage.interface-Dl8SLUd1.js';
+import { m as ExternalStates, o as Effect } from './dispatcher.module-jd8U_ZEs.js';
+
+type ExtractDispatchType<T> = T extends {
+    dispatch: infer D;
+} ? D : never;
+type StorageCreatorFunction<T extends Record<string, any>> = () => Promise<IStorage<T>>;
+/**
+ * Базовая конфигурация хранилища
+ */
+type BaseSynapseConfig<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = ({
+    storage: IStorage<TStore>;
+    createStorageFn?: undefined;
+} | {
+    storage?: undefined;
+    createStorageFn: StorageCreatorFunction<TStore>;
+}) & {
+    externalSelectors?: TExternalSelectors;
+    createSelectorsFn?: (selectorModule: ISelectorModule<TStore>, externalSelectors: TExternalSelectors) => TSelectors;
+};
+/**
+ * Конфигурация с dispatcher и effects
+ */
+type CreateSynapseConfigWithEffects<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
+    createEffectConfig: (dispatcher: TDispatcher) => {
+        dispatchers: Record<string, any>;
+        api?: TApi;
+        config?: TConfig;
+        externalStates?: ExternalStates;
+    };
+    effects?: Effect<TStore, any, TApi, TConfig, any>[];
+};
+/**
+ * Конфигурация только с dispatcher
+ */
+type CreateSynapseConfigWithDispatcher<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
+    createEffectConfig?: never;
+    effects?: never;
+};
+/**
+ * Конфигурация без dispatcher
+ */
+type CreateSynapseConfigBasic<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
+    createDispatcherFn?: never;
+    createEffectConfig?: never;
+    effects?: never;
+};
+/**
+ * Результат с dispatcher и effects
+ */
+interface SynapseStoreWithEffects<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
+    storage: TStorage;
+    selectors: TSelectors;
+    actions: TActions;
+    state$: Observable<TStore>;
+    dispatcher: any;
+    destroy: () => Promise<void>;
+}
+/**
+ * Результат только с dispatcher
+ */
+interface SynapseStoreWithDispatcher<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
+    storage: TStorage;
+    selectors: TSelectors;
+    actions: TActions;
+    dispatcher: any;
+    destroy: () => Promise<void>;
+}
+/**
+ * Результат без dispatcher
+ */
+interface SynapseStoreBasic<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors> {
+    storage: TStorage;
+    selectors: TSelectors;
+    destroy: () => Promise<void>;
+}
+/**
+ * Union-тип для всех возможных результатов createSynapse
+ */
+type AnySynapseStore<TStore extends Record<string, any> = any, TStorage extends IStorage<TStore> = IStorage<any>, TSelectors = any, TActions = any> = SynapseStoreWithEffects<TStore, TStorage, TSelectors, TActions> | SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, TActions> | SynapseStoreBasic<TStore, TStorage, TSelectors>;
+/**
+ * Перегрузки функции createSynapse
+ */
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithEffects<TStore, TSelectors, TDispatcher, TApi, TConfig, TExternalSelectors>): Promise<SynapseStoreWithEffects<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithDispatcher<TStore, TSelectors, TDispatcher, TExternalSelectors>): Promise<SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
+declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigBasic<TStore, TSelectors, TExternalSelectors>): Promise<SynapseStoreBasic<TStore, TStorage, TSelectors>>;
+
+export { type AnySynapseStore, type SynapseStoreBasic, type SynapseStoreWithDispatcher, type SynapseStoreWithEffects, createSynapse };

package/dist/utils.js

@@ -0,0 +1 @@
+export{a as createSynapse}from'./chunk-WQNH3LVB.js';import'./chunk-6RNZVHSR.js';import'./chunk-IPUPRMZK.js';import'./chunk-ZE2EJX2Y.js';import'./chunk-5X65PSGD.js';