synapse-storage 3.0.19 → 4.0.1

package/dist/react/hooks/useSelector.js

@@ -0,0 +1,56 @@
+import { useCallback, useRef, useSyncExternalStore } from "react";
+
+
+
+function useSelector(selector, options) {
+    const equalsRef = useRef(options?.equals);
+    // Кеш для мемоизации результата getSnapshot (предотвращает лишние ререндеры)
+    const cachedRef = useRef(undefined);
+    const subscribe = useCallback((onStoreChange)=>{
+        return selector.subscribe({
+            notify: ()=>{
+                onStoreChange();
+            }
+        });
+    }, [
+        selector
+    ]);
+    const getSnapshot = useCallback(()=>{
+        const value = selector.selectSync();
+        // Если есть пользовательская функция сравнения — мемоизируем
+        const equals = equalsRef.current;
+        if (equals && cachedRef.current !== undefined && equals(cachedRef.current, value)) {
+            return cachedRef.current;
+        }
+        cachedRef.current = value;
+        return value;
+    }, [
+        selector
+    ]);
+    const value = useSyncExternalStore(subscribe, getSnapshot);
+    // Подписка на статус готовности storage (используется только при withLoading)
+    const subscribeToStatus = useCallback((onStoreChange)=>{
+        return selector.onSourceStatusChange(()=>{
+            onStoreChange();
+        });
+    }, [
+        selector
+    ]);
+    const getStatusSnapshot = useCallback(()=>{
+        return !selector.isSourceReady();
+    }, [
+        selector
+    ]);
+    const isLoading = useSyncExternalStore(subscribeToStatus, getStatusSnapshot);
+    if (options?.withLoading) {
+        return {
+            data: value,
+            isLoading
+        };
+    }
+    return value;
+}
+
+export { useSelector };
+
+//# sourceMappingURL=useSelector.js.map

package/dist/react/hooks/useSelector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react/hooks/useSelector.js","sources":["../../../src/react/hooks/useSelector.ts"],"sourcesContent":["import { useCallback, useRef, useSyncExternalStore } from 'react'\n\nimport type { SelectorAPI } from '../../core'\n\ninterface UseSelectorOptions<T> {\n  /** Функция сравнения для предотвращения лишних ререндеров */\n  equals?: (a: T, b: T) => boolean\n  /** Включать ли статус загрузки в возвращаемый результат */\n  withLoading?: boolean\n}\n\n/**\n * Хук для использования селекторов в компонентах React.\n * Использует useSyncExternalStore для корректной работы в Concurrent Mode.\n * Подписывается напрямую через selector.subscribe() — без глобального реестра.\n */\nexport function useSelector<T>(selector: SelectorAPI<T>): T\nexport function useSelector<T>(selector: SelectorAPI<T>, options: UseSelectorOptions<T> & { withLoading: true }): { data: T; isLoading: boolean }\nexport function useSelector<T>(selector: SelectorAPI<T>, options?: UseSelectorOptions<T>): { data: T; isLoading: boolean } | T {\n  const equalsRef = useRef(options?.equals)\n\n  // Кеш для мемоизации результата getSnapshot (предотвращает лишние ререндеры)\n  const cachedRef = useRef<T | undefined>(undefined)\n\n  const subscribe = useCallback(\n    (onStoreChange: VoidFunction) => {\n      return selector.subscribe({\n        notify: () => {\n          onStoreChange()\n        },\n      })\n    },\n    [selector],\n  )\n\n  const getSnapshot = useCallback((): T => {\n    const value = selector.selectSync()\n\n    // Если есть пользовательская функция сравнения — мемоизируем\n    const equals = equalsRef.current\n    if (equals && cachedRef.current !== undefined && equals(cachedRef.current, value)) {\n      return cachedRef.current\n    }\n\n    cachedRef.current = value\n    return value\n  }, [selector])\n\n  const value = useSyncExternalStore(subscribe, getSnapshot)\n\n  // Подписка на статус готовности storage (используется только при withLoading)\n  const subscribeToStatus = useCallback(\n    (onStoreChange: VoidFunction) => {\n      return selector.onSourceStatusChange(() => {\n        onStoreChange()\n      })\n    },\n    [selector],\n  )\n\n  const getStatusSnapshot = useCallback((): boolean => {\n    return !selector.isSourceReady()\n  }, [selector])\n\n  const isLoading = useSyncExternalStore(subscribeToStatus, getStatusSnapshot)\n\n  if (options?.withLoading) {\n    return { data: value, isLoading }\n  }\n\n  return value\n}\n"],"names":["useCallback","useRef","useSyncExternalStore","useSelector","selector","options","equalsRef","cachedRef","undefined","subscribe","onStoreChange","getSnapshot","value","equals","subscribeToStatus","getStatusSnapshot","isLoading"],"mappings":";;;AAAiE;AAkB1D,SAASG,WAAWA,CAAIC,QAAwB,EAAEC,OAA+B;IACtF,MAAMC,YAAYL,MAAMA,CAACI,SAAS;IAElC,6EAA6E;IAC7E,MAAME,YAAYN,MAAMA,CAAgBO;IAExC,MAAMC,YAAYT,WAAWA,CAC3B,CAACU;QACC,OAAON,SAAS,SAAS,CAAC;YACxB,QAAQ;gBACNM;YACF;QACF;IACF,GACA;QAACN;KAAS;IAGZ,MAAMO,cAAcX,WAAWA,CAAC;QAC9B,MAAMY,QAAQR,SAAS,UAAU;QAEjC,6DAA6D;QAC7D,MAAMS,SAASP,UAAU,OAAO;QAChC,IAAIO,UAAUN,UAAU,OAAO,KAAKC,aAAaK,OAAON,UAAU,OAAO,EAAEK,QAAQ;YACjF,OAAOL,UAAU,OAAO;QAC1B;QAEAA,UAAU,OAAO,GAAGK;QACpB,OAAOA;IACT,GAAG;QAACR;KAAS;IAEb,MAAMQ,QAAQV,oBAAoBA,CAACO,WAAWE;IAE9C,8EAA8E;IAC9E,MAAMG,oBAAoBd,WAAWA,CACnC,CAACU;QACC,OAAON,SAAS,oBAAoB,CAAC;YACnCM;QACF;IACF,GACA;QAACN;KAAS;IAGZ,MAAMW,oBAAoBf,WAAWA,CAAC;QACpC,OAAO,CAACI,SAAS,aAAa;IAChC,GAAG;QAACA;KAAS;IAEb,MAAMY,YAAYd,oBAAoBA,CAACY,mBAAmBC;IAE1D,IAAIV,SAAS,aAAa;QACxB,OAAO;YAAE,MAAMO;YAAOI;QAAU;IAClC;IAEA,OAAOJ;AACT"}

package/dist/react/hooks/useStorage.d.ts

@@ -0,0 +1,39 @@
+import { IStorageBase, StorageInitStatus } from '../../core';
+export interface UseStorageOptions {
+    /**
+     * Автоматически инициализировать при монтировании (по умолчанию true)
+     */
+    autoInitialize?: boolean;
+}
+export type UseStorageReturn<S> = {
+    storage: S;
+    status: StorageInitStatus;
+    initialize: () => Promise<void>;
+    isReady: true;
+    isLoading: false;
+    hasError: false;
+} | {
+    storage: S;
+    status: StorageInitStatus;
+    initialize: () => Promise<void>;
+    isReady: false;
+    isLoading: boolean;
+    hasError: boolean;
+};
+/**
+ * Хук для управления lifecycle внешнего хранилища.
+ *
+ * В отличие от useCreateStorage, не создаёт и не уничтожает хранилище —
+ * только инициализирует и отслеживает статус.
+ *
+ * Предназначен для хранилищ, созданных вне компонентов (на уровне модуля):
+ * ```ts
+ * // stores.ts
+ * export const todoStorage = new IndexedDBStorage({ name: 'todos', ... })
+ *
+ * // Component.tsx
+ * const { isReady } = useStorage(todoStorage)
+ * ```
+ */
+export declare function useStorage<S extends IStorageBase<any>>(storage: S, options?: UseStorageOptions): UseStorageReturn<S>;
+//# sourceMappingURL=useStorage.d.ts.map

package/dist/react/hooks/useStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStorage.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useStorage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAiB,MAAM,YAAY,CAAA;AAE3E,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAC1B;IACE,OAAO,EAAE,CAAC,CAAA;IACV,MAAM,EAAE,iBAAiB,CAAA;IACzB,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/B,OAAO,EAAE,IAAI,CAAA;IACb,SAAS,EAAE,KAAK,CAAA;IAChB,QAAQ,EAAE,KAAK,CAAA;CAChB,GACD;IACE,OAAO,EAAE,CAAC,CAAA;IACV,MAAM,EAAE,iBAAiB,CAAA;IACzB,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/B,OAAO,EAAE,KAAK,CAAA;IACd,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAEL;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAgDxH"}

package/dist/react/hooks/useStorage.js

@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useState } from "react";
+import { StorageStatus } from "../../core/index.js";
+
+
+
+
+
+/**
+ * Хук для управления lifecycle внешнего хранилища.
+ *
+ * В отличие от useCreateStorage, не создаёт и не уничтожает хранилище —
+ * только инициализирует и отслеживает статус.
+ *
+ * Предназначен для хранилищ, созданных вне компонентов (на уровне модуля):
+ * ```ts
+ * // stores.ts
+ * export const todoStorage = new IndexedDBStorage({ name: 'todos', ... })
+ *
+ * // Component.tsx
+ * const { isReady } = useStorage(todoStorage)
+ * ```
+ */ function useStorage(storage, options = {}) {
+    const { autoInitialize = true } = options;
+    const [status, setStatus] = useState({
+        status: StorageStatus.IDLE
+    });
+    const initialize = useCallback(async ()=>{
+        try {
+            await storage.initialize();
+        } catch  {
+        // Ошибка будет отражена через onStatusChange
+        }
+    }, [
+        storage
+    ]);
+    // Подписка на изменения статуса
+    useEffect(()=>{
+        return storage.onStatusChange(setStatus);
+    }, [
+        storage
+    ]);
+    // Автоинициализация
+    useEffect(()=>{
+        if (autoInitialize && status.status === StorageStatus.IDLE) {
+            initialize();
+        }
+    }, [
+        autoInitialize,
+        storage,
+        status.status,
+        initialize
+    ]);
+    const isReady = status.status === StorageStatus.READY;
+    const isLoading = status.status === StorageStatus.LOADING;
+    const hasError = status.status === StorageStatus.ERROR;
+    if (isReady) {
+        return {
+            storage,
+            status,
+            initialize,
+            isReady: true,
+            isLoading: false,
+            hasError: false
+        };
+    }
+    return {
+        storage,
+        status,
+        initialize,
+        isReady: false,
+        isLoading,
+        hasError
+    };
+}
+
+export { useStorage };
+
+//# sourceMappingURL=useStorage.js.map

package/dist/react/hooks/useStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react/hooks/useStorage.js","sources":["../../../src/react/hooks/useStorage.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react'\n\nimport { IStorageBase, StorageInitStatus, StorageStatus } from '../../core'\n\nexport interface UseStorageOptions {\n  /**\n   * Автоматически инициализировать при монтировании (по умолчанию true)\n   */\n  autoInitialize?: boolean\n}\n\nexport type UseStorageReturn<S> =\n  | {\n      storage: S\n      status: StorageInitStatus\n      initialize: () => Promise<void>\n      isReady: true\n      isLoading: false\n      hasError: false\n    }\n  | {\n      storage: S\n      status: StorageInitStatus\n      initialize: () => Promise<void>\n      isReady: false\n      isLoading: boolean\n      hasError: boolean\n    }\n\n/**\n * Хук для управления lifecycle внешнего хранилища.\n *\n * В отличие от useCreateStorage, не создаёт и не уничтожает хранилище —\n * только инициализирует и отслеживает статус.\n *\n * Предназначен для хранилищ, созданных вне компонентов (на уровне модуля):\n * ```ts\n * // stores.ts\n * export const todoStorage = new IndexedDBStorage({ name: 'todos', ... })\n *\n * // Component.tsx\n * const { isReady } = useStorage(todoStorage)\n * ```\n */\nexport function useStorage<S extends IStorageBase<any>>(storage: S, options: UseStorageOptions = {}): UseStorageReturn<S> {\n  const { autoInitialize = true } = options\n\n  const [status, setStatus] = useState<StorageInitStatus>({ status: StorageStatus.IDLE })\n\n  const initialize = useCallback(async () => {\n    try {\n      await storage.initialize()\n    } catch {\n      // Ошибка будет отражена через onStatusChange\n    }\n  }, [storage])\n\n  // Подписка на изменения статуса\n  useEffect(() => {\n    return storage.onStatusChange(setStatus)\n  }, [storage])\n\n  // Автоинициализация\n  useEffect(() => {\n    if (autoInitialize && status.status === StorageStatus.IDLE) {\n      initialize()\n    }\n  }, [autoInitialize, storage, status.status, initialize])\n\n  const isReady = status.status === StorageStatus.READY\n  const isLoading = status.status === StorageStatus.LOADING\n  const hasError = status.status === StorageStatus.ERROR\n\n  if (isReady) {\n    return {\n      storage,\n      status,\n      initialize,\n      isReady: true as const,\n      isLoading: false as const,\n      hasError: false as const,\n    }\n  }\n\n  return {\n    storage,\n    status,\n    initialize,\n    isReady: false as const,\n    isLoading,\n    hasError,\n  }\n}\n"],"names":["useCallback","useEffect","useState","StorageStatus","useStorage","storage","options","autoInitialize","status","setStatus","initialize","isReady","isLoading","hasError"],"mappings":";;;;;AAAwD;AAEmB;AA2B3E;;;;;;;;;;;;;;CAcC,GACM,SAASI,UAAUA,CAA8BC,OAAU,EAAEC,UAA6B,CAAC,CAAC;IACjG,MAAM,EAAEC,iBAAiB,IAAI,EAAE,GAAGD;IAElC,MAAM,CAACE,QAAQC,UAAU,GAAGP,QAAQA,CAAoB;QAAE,QAAQC,kBAAkB;IAAC;IAErF,MAAMO,aAAaV,WAAWA,CAAC;QAC7B,IAAI;YACF,MAAMK,QAAQ,UAAU;QAC1B,EAAE,OAAM;QACN,6CAA6C;QAC/C;IACF,GAAG;QAACA;KAAQ;IAEZ,gCAAgC;IAChCJ,SAASA,CAAC;QACR,OAAOI,QAAQ,cAAc,CAACI;IAChC,GAAG;QAACJ;KAAQ;IAEZ,oBAAoB;IACpBJ,SAASA,CAAC;QACR,IAAIM,kBAAkBC,OAAO,MAAM,KAAKL,kBAAkB,EAAE;YAC1DO;QACF;IACF,GAAG;QAACH;QAAgBF;QAASG,OAAO,MAAM;QAAEE;KAAW;IAEvD,MAAMC,UAAUH,OAAO,MAAM,KAAKL,mBAAmB;IACrD,MAAMS,YAAYJ,OAAO,MAAM,KAAKL,qBAAqB;IACzD,MAAMU,WAAWL,OAAO,MAAM,KAAKL,mBAAmB;IAEtD,IAAIQ,SAAS;QACX,OAAO;YACLN;YACAG;YACAE;YACA,SAAS;YACT,WAAW;YACX,UAAU;QACZ;IACF;IAEA,OAAO;QACLL;QACAG;QACAE;QACA,SAAS;QACTE;QACAC;IACF;AACF"}

package/dist/react/hooks/useStorageSubscribe.d.ts

@@ -0,0 +1,16 @@
+import { IStorageBase } from '../../core';
+/**
+ * Хук для подписки на изменения в хранилище.
+ * Использует useSyncExternalStore для корректной работы в Concurrent Mode.
+ *
+ * Принимает IStorageBase (общий интерфейс для sync и async хранилищ),
+ * так как подписки одинаковы для всех типов.
+ *
+ * @template S - Тип состояния хранилища
+ * @template R - Тип возвращаемого значения
+ * @param storage - Экземпляр хранилища или null (до инициализации)
+ * @param selector - Функция-селектор для выбора данных
+ * @returns Значение из хранилища
+ */
+export declare const useStorageSubscribe: <S extends Record<string, any>, R = any>(storage: IStorageBase<S> | null, selector: (state: S) => R) => R | undefined;
+//# sourceMappingURL=useStorageSubscribe.d.ts.map

package/dist/react/hooks/useStorageSubscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStorageSubscribe.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useStorageSubscribe.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAAG,CAAC,GAAG,SAmC5I,CAAA"}

package/dist/react/hooks/useStorageSubscribe.js

@@ -0,0 +1,55 @@
+import { useCallback, useRef, useSyncExternalStore } from "react";
+import { logError } from "../../_utils/error-handling.util.js";
+
+
+
+
+
+/**
+ * Хук для подписки на изменения в хранилище.
+ * Использует useSyncExternalStore для корректной работы в Concurrent Mode.
+ *
+ * Принимает IStorageBase (общий интерфейс для sync и async хранилищ),
+ * так как подписки одинаковы для всех типов.
+ *
+ * @template S - Тип состояния хранилища
+ * @template R - Тип возвращаемого значения
+ * @param storage - Экземпляр хранилища или null (до инициализации)
+ * @param selector - Функция-селектор для выбора данных
+ * @returns Значение из хранилища
+ */ const useStorageSubscribe = (storage, selector)=>{
+    // Храним selector в ref, чтобы не пересоздавать subscribe/getSnapshot при изменении ссылки
+    const selectorRef = useRef(selector);
+    selectorRef.current = selector;
+    const subscribe = useCallback((onStoreChange)=>{
+        if (!storage) return ()=>{};
+        // Подписка на все изменения storage + на смену статуса (для момента инициализации)
+        const unsubData = storage.subscribeToAll(()=>onStoreChange());
+        const unsubStatus = storage.onStatusChange(()=>onStoreChange());
+        return ()=>{
+            unsubData();
+            unsubStatus();
+        };
+    }, [
+        storage
+    ]);
+    const getSnapshot = useCallback(()=>{
+        if (!storage) return undefined;
+        try {
+            const state = storage.getStateSync();
+            return selectorRef.current(state);
+        } catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                logError('useStorageSubscribe: selector error', error, null, 'warn');
+            }
+            return undefined;
+        }
+    }, [
+        storage
+    ]);
+    return useSyncExternalStore(subscribe, getSnapshot);
+};
+
+export { useStorageSubscribe };
+
+//# sourceMappingURL=useStorageSubscribe.js.map

package/dist/react/hooks/useStorageSubscribe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react/hooks/useStorageSubscribe.js","sources":["../../../src/react/hooks/useStorageSubscribe.ts"],"sourcesContent":["import { useCallback, useRef, useSyncExternalStore } from 'react'\n\nimport { logError } from '../../_utils/error-handling.util'\nimport { IStorageBase } from '../../core'\n\n/**\n * Хук для подписки на изменения в хранилище.\n * Использует useSyncExternalStore для корректной работы в Concurrent Mode.\n *\n * Принимает IStorageBase (общий интерфейс для sync и async хранилищ),\n * так как подписки одинаковы для всех типов.\n *\n * @template S - Тип состояния хранилища\n * @template R - Тип возвращаемого значения\n * @param storage - Экземпляр хранилища или null (до инициализации)\n * @param selector - Функция-селектор для выбора данных\n * @returns Значение из хранилища\n */\nexport const useStorageSubscribe = <S extends Record<string, any>, R = any>(storage: IStorageBase<S> | null, selector: (state: S) => R): R | undefined => {\n  // Храним selector в ref, чтобы не пересоздавать subscribe/getSnapshot при изменении ссылки\n  const selectorRef = useRef(selector)\n  selectorRef.current = selector\n\n  const subscribe = useCallback(\n    (onStoreChange: VoidFunction) => {\n      if (!storage) return () => {}\n\n      // Подписка на все изменения storage + на смену статуса (для момента инициализации)\n      const unsubData = storage.subscribeToAll(() => onStoreChange())\n      const unsubStatus = storage.onStatusChange(() => onStoreChange())\n      return () => {\n        unsubData()\n        unsubStatus()\n      }\n    },\n    [storage],\n  )\n\n  const getSnapshot = useCallback((): R | undefined => {\n    if (!storage) return undefined\n\n    try {\n      const state = storage.getStateSync()\n      return selectorRef.current(state)\n    } catch (error) {\n      if (process.env.NODE_ENV !== 'production') {\n        logError('useStorageSubscribe: selector error', error, null, 'warn')\n      }\n      return undefined\n    }\n  }, [storage])\n\n  return useSyncExternalStore(subscribe, getSnapshot)\n}\n"],"names":["useCallback","useRef","useSyncExternalStore","logError","useStorageSubscribe","storage","selector","selectorRef","subscribe","onStoreChange","unsubData","unsubStatus","getSnapshot","undefined","state","error","process"],"mappings":";;;;;AAAiE;AAEN;AAG3D;;;;;;;;;;;;CAYC,GACM,MAAMI,mBAAmBA,GAAG,CAAyCC,SAAiCC;IAC3G,2FAA2F;IAC3F,MAAMC,cAAcN,MAAMA,CAACK;IAC3BC,YAAY,OAAO,GAAGD;IAEtB,MAAME,YAAYR,WAAWA,CAC3B,CAACS;QACC,IAAI,CAACJ,SAAS,OAAO,KAAO;QAE5B,mFAAmF;QACnF,MAAMK,YAAYL,QAAQ,cAAc,CAAC,IAAMI;QAC/C,MAAME,cAAcN,QAAQ,cAAc,CAAC,IAAMI;QACjD,OAAO;YACLC;YACAC;QACF;IACF,GACA;QAACN;KAAQ;IAGX,MAAMO,cAAcZ,WAAWA,CAAC;QAC9B,IAAI,CAACK,SAAS,OAAOQ;QAErB,IAAI;YACF,MAAMC,QAAQT,QAAQ,YAAY;YAClC,OAAOE,YAAY,OAAO,CAACO;QAC7B,EAAE,OAAOC,OAAO;YACd,IAAIC,QAAQ,GAAG,CAAC,QAAQ,KAAK,cAAc;gBACzCb,QAAQA,CAAC,uCAAuCY,OAAO,MAAM;YAC/D;YACA,OAAOF;QACT;IACF,GAAG;QAACR;KAAQ;IAEZ,OAAOH,oBAAoBA,CAACM,WAAWI;AACzC,EAAC"}

package/dist/react/index.d.ts

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

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

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

package/dist/react/index.js

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

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react/index.js","sources":["../../src/react/index.ts"],"sourcesContent":["export * from './hooks'\nexport * from './utils'\n"],"names":[],"mappings":";;AAAuB;AACA"}

package/dist/react/utils/awaitSynapse.d.ts

@@ -0,0 +1,34 @@
+import { ComponentType, ReactNode } from 'react';
+import { IStorage } from '../../core';
+import { AnySynapseStore } from '../../utils';
+interface ReactAwaitSynapseOptions {
+    loadingComponent?: ReactNode;
+    errorComponent?: (error: Error) => ReactNode;
+}
+/**
+ * React-обертка для фреймворк-независимой утилиты ожидания Synapse
+ * Добавляет React-специфичные методы поверх createSynapseAwaiter
+ */
+export declare function awaitSynapse<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors = any, TActions = any>(synapseStorePromise: Promise<AnySynapseStore<TStore, TStorage, TSelectors, TActions>> | AnySynapseStore<TStore, TStorage, TSelectors, TActions>, options?: ReactAwaitSynapseOptions): {
+    withSynapseReady: <ComponentProps>(Component: ComponentType<ComponentProps>) => {
+        (props: ComponentProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    useSynapseReady: () => {
+        isReady: boolean;
+        isError: boolean;
+        isPending: boolean;
+        store: AnySynapseStore<TStore, TStorage, TSelectors, TActions> | undefined;
+        error: Error | null;
+    };
+    waitForReady: () => Promise<AnySynapseStore<TStore, TStorage, TSelectors, TActions>>;
+    isReady: () => boolean;
+    getStoreIfReady: () => AnySynapseStore<TStore, TStorage, TSelectors, TActions> | undefined;
+    onReady: (cb: Parameters<(callback: (store: AnySynapseStore<TStore, TStorage, TSelectors, TActions>) => void) => VoidFunction>[0]) => VoidFunction;
+    onError: (cb: Parameters<(callback: (error: Error) => void) => VoidFunction>[0]) => VoidFunction;
+    getStatus: () => "error" | "ready" | "pending";
+    getError: () => Error | null;
+    destroy: () => void;
+};
+export {};
+//# sourceMappingURL=awaitSynapse.d.ts.map

package/dist/react/utils/awaitSynapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaitSynapse.d.ts","sourceRoot":"","sources":["../../../src/react/utils/awaitSynapse.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,SAAS,EAAuB,MAAM,OAAO,CAAA;AAExF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,eAAe,EAAwB,MAAM,aAAa,CAAA;AAEnE,UAAU,wBAAwB;IAChC,gBAAgB,CAAC,EAAE,SAAS,CAAA;IAC5B,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAA;CAC7C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,GAAG,EAAE,QAAQ,GAAG,GAAG,EAClI,mBAAmB,EAAE,OAAO,CAAC,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,EAC/I,OAAO,CAAC,EAAE,wBAAwB;uBAuDR,cAAc,aAAa,aAAa,CAAC,cAAc,CAAC;gBAC/C,cAAc;;;;;;;;;;;;;kBA6BjC,UAAU,sGAAwB,CAAC,CAAC,CAAC;kBACrC,UAAU,oDAAwB,CAAC,CAAC,CAAC;;;;EAKtD"}

package/dist/react/utils/awaitSynapse.js

@@ -0,0 +1,87 @@
+import { useEffect, useState } from "react";
+import { createSynapseAwaiter } from "../../utils/index.js";
+
+
+
+
+
+/**
+ * React-обертка для фреймворк-независимой утилиты ожидания Synapse
+ * Добавляет React-специфичные методы поверх createSynapseAwaiter
+ */ function awaitSynapse(synapseStorePromise, options) {
+    const { loadingComponent = /*#__PURE__*/ React.createElement("div", null, "Инициализация..."), errorComponent = (error)=>/*#__PURE__*/ React.createElement("div", null, "Ошибка инициализации: ", error.message) } = options || {};
+    const awaiter = createSynapseAwaiter(synapseStorePromise);
+    /**
+   * Хук для получения текущего состояния готовности
+   */ function useSynapseReady() {
+        const [status, setStatus] = useState(()=>awaiter.getStatus());
+        const [store, setStore] = useState(()=>awaiter.getStoreIfReady());
+        const [error, setError] = useState(()=>awaiter.getError());
+        useEffect(()=>{
+            // Проверяем текущее состояние при монтировании
+            const currentStatus = awaiter.getStatus();
+            const currentStore = awaiter.getStoreIfReady();
+            const currentError = awaiter.getError();
+            setStatus(currentStatus);
+            setStore(currentStore);
+            setError(currentError);
+            // Подписываемся на изменения
+            const unsubscribeReady = awaiter.onReady((readyStore)=>{
+                setStatus('ready');
+                setStore(readyStore);
+                setError(null);
+            });
+            const unsubscribeError = awaiter.onError((err)=>{
+                setStatus('error');
+                setStore(undefined);
+                setError(err);
+            });
+            return ()=>{
+                unsubscribeReady();
+                unsubscribeError();
+            };
+        }, []);
+        return {
+            isReady: status === 'ready',
+            isError: status === 'error',
+            isPending: status === 'pending',
+            store,
+            error
+        };
+    }
+    /**
+   * Обертка, которая ждет готовности Synapse
+   */ function withSynapseReady(Component) {
+        function WrappedComponent(props) {
+            const { isReady, isError, error } = useSynapseReady();
+            // Показываем ошибку
+            if (isError && error) return /*#__PURE__*/ React.createElement(React.Fragment, null, errorComponent(error));
+            // Показываем загрузку
+            if (!isReady) return /*#__PURE__*/ React.createElement(React.Fragment, null, loadingComponent);
+            // Рендерим компонент когда все готово
+            return /*#__PURE__*/ React.createElement(Component, props);
+        }
+        // Устанавливаем отображаемое имя для отладки
+        const componentName = Component.displayName || Component.name || 'Component';
+        WrappedComponent.displayName = `AwaitSynapse(${componentName})`;
+        return WrappedComponent;
+    }
+    return {
+        // React методы
+        withSynapseReady,
+        useSynapseReady,
+        // Проксируем все методы из awaiter (обёртки сохраняют контекст при деструктуризации)
+        waitForReady: ()=>awaiter.waitForReady(),
+        isReady: ()=>awaiter.isReady(),
+        getStoreIfReady: ()=>awaiter.getStoreIfReady(),
+        onReady: (cb)=>awaiter.onReady(cb),
+        onError: (cb)=>awaiter.onError(cb),
+        getStatus: ()=>awaiter.getStatus(),
+        getError: ()=>awaiter.getError(),
+        destroy: ()=>awaiter.destroy()
+    };
+}
+
+export { awaitSynapse };
+
+//# sourceMappingURL=awaitSynapse.js.map

package/dist/react/utils/awaitSynapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react/utils/awaitSynapse.js","sources":["../../../src/react/utils/awaitSynapse.tsx"],"sourcesContent":["import { ComponentType, PropsWithChildren, ReactNode, useEffect, useState } from 'react'\n\nimport { IStorage } from '../../core'\nimport { AnySynapseStore, createSynapseAwaiter } from '../../utils'\n\ninterface ReactAwaitSynapseOptions {\n  loadingComponent?: ReactNode\n  errorComponent?: (error: Error) => ReactNode\n}\n\n/**\n * React-обертка для фреймворк-независимой утилиты ожидания Synapse\n * Добавляет React-специфичные методы поверх createSynapseAwaiter\n */\nexport function awaitSynapse<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors = any, TActions = any>(\n  synapseStorePromise: Promise<AnySynapseStore<TStore, TStorage, TSelectors, TActions>> | AnySynapseStore<TStore, TStorage, TSelectors, TActions>,\n  options?: ReactAwaitSynapseOptions,\n) {\n  const { loadingComponent = <div>Инициализация...</div>, errorComponent = (error: Error) => <div>Ошибка инициализации: {error.message}</div> } = options || {}\n\n  const awaiter = createSynapseAwaiter(synapseStorePromise)\n\n  /**\n   * Хук для получения текущего состояния готовности\n   */\n  function useSynapseReady() {\n    const [status, setStatus] = useState<'pending' | 'ready' | 'error'>(() => awaiter.getStatus())\n    const [store, setStore] = useState<AnySynapseStore<TStore, TStorage, TSelectors, TActions> | undefined>(() => awaiter.getStoreIfReady())\n    const [error, setError] = useState<Error | null>(() => awaiter.getError())\n\n    useEffect(() => {\n      // Проверяем текущее состояние при монтировании\n      const currentStatus = awaiter.getStatus()\n      const currentStore = awaiter.getStoreIfReady()\n      const currentError = awaiter.getError()\n\n      setStatus(currentStatus)\n      setStore(currentStore)\n      setError(currentError)\n\n      // Подписываемся на изменения\n      const unsubscribeReady = awaiter.onReady((readyStore) => {\n        setStatus('ready')\n        setStore(readyStore)\n        setError(null)\n      })\n\n      const unsubscribeError = awaiter.onError((err) => {\n        setStatus('error')\n        setStore(undefined)\n        setError(err)\n      })\n\n      return () => {\n        unsubscribeReady()\n        unsubscribeError()\n      }\n    }, [])\n\n    return {\n      isReady: status === 'ready',\n      isError: status === 'error',\n      isPending: status === 'pending',\n      store,\n      error,\n    }\n  }\n\n  /**\n   * Обертка, которая ждет готовности Synapse\n   */\n  function withSynapseReady<ComponentProps>(Component: ComponentType<ComponentProps>) {\n    function WrappedComponent(props: ComponentProps) {\n      const { isReady, isError, error } = useSynapseReady()\n\n      // Показываем ошибку\n      if (isError && error) return <>{errorComponent(error)}</>\n\n      // Показываем загрузку\n      if (!isReady) return <>{loadingComponent}</>\n\n      // Рендерим компонент когда все готово\n      return <Component {...(props as PropsWithChildren<ComponentProps>)} />\n    }\n\n    // Устанавливаем отображаемое имя для отладки\n    const componentName = Component.displayName || Component.name || 'Component'\n    WrappedComponent.displayName = `AwaitSynapse(${componentName})`\n\n    return WrappedComponent\n  }\n\n  return {\n    // React методы\n    withSynapseReady,\n    useSynapseReady,\n\n    // Проксируем все методы из awaiter (обёртки сохраняют контекст при деструктуризации)\n    waitForReady: () => awaiter.waitForReady(),\n    isReady: () => awaiter.isReady(),\n    getStoreIfReady: () => awaiter.getStoreIfReady(),\n    onReady: (cb: Parameters<typeof awaiter.onReady>[0]) => awaiter.onReady(cb),\n    onError: (cb: Parameters<typeof awaiter.onError>[0]) => awaiter.onError(cb),\n    getStatus: () => awaiter.getStatus(),\n    getError: () => awaiter.getError(),\n    destroy: () => awaiter.destroy(),\n  }\n}\n"],"names":["useEffect","useState","createSynapseAwaiter","awaitSynapse","synapseStorePromise","options","loadingComponent","errorComponent","error","awaiter","useSynapseReady","status","setStatus","store","setStore","setError","currentStatus","currentStore","currentError","unsubscribeReady","readyStore","unsubscribeError","err","undefined","withSynapseReady","Component","WrappedComponent","props","isReady","isError","componentName","cb"],"mappings":";;;;;AAAwF;AAGrB;AAOnE;;;CAGC,GACM,SAASG,YAAYA,CAC1BC,mBAA+I,EAC/IC,OAAkC;IAElC,MAAM,EAAEC,iCAAmB,oBAAC,aAAI,mBAAsB,EAAEC,iBAAiB,CAACC,sBAAiB,oBAAC,aAAI,0BAAuBA,MAAM,OAAO,CAAO,EAAE,GAAGH,WAAW,CAAC;IAE5J,MAAMI,UAAUP,oBAAoBA,CAACE;IAErC;;GAEC,GACD,SAASM;QACP,MAAM,CAACC,QAAQC,UAAU,GAAGX,QAAQA,CAAgC,IAAMQ,QAAQ,SAAS;QAC3F,MAAM,CAACI,OAAOC,SAAS,GAAGb,QAAQA,CAAsE,IAAMQ,QAAQ,eAAe;QACrI,MAAM,CAACD,OAAOO,SAAS,GAAGd,QAAQA,CAAe,IAAMQ,QAAQ,QAAQ;QAEvET,SAASA,CAAC;YACR,+CAA+C;YAC/C,MAAMgB,gBAAgBP,QAAQ,SAAS;YACvC,MAAMQ,eAAeR,QAAQ,eAAe;YAC5C,MAAMS,eAAeT,QAAQ,QAAQ;YAErCG,UAAUI;YACVF,SAASG;YACTF,SAASG;YAET,6BAA6B;YAC7B,MAAMC,mBAAmBV,QAAQ,OAAO,CAAC,CAACW;gBACxCR,UAAU;gBACVE,SAASM;gBACTL,SAAS;YACX;YAEA,MAAMM,mBAAmBZ,QAAQ,OAAO,CAAC,CAACa;gBACxCV,UAAU;gBACVE,SAASS;gBACTR,SAASO;YACX;YAEA,OAAO;gBACLH;gBACAE;YACF;QACF,GAAG,EAAE;QAEL,OAAO;YACL,SAASV,WAAW;YACpB,SAASA,WAAW;YACpB,WAAWA,WAAW;YACtBE;YACAL;QACF;IACF;IAEA;;GAEC,GACD,SAASgB,iBAAiCC,SAAwC;QAChF,SAASC,iBAAiBC,KAAqB;YAC7C,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAErB,KAAK,EAAE,GAAGE;YAEpC,oBAAoB;YACpB,IAAImB,WAAWrB,OAAO,qBAAO,0CAAGD,eAAeC;YAE/C,sBAAsB;YACtB,IAAI,CAACoB,SAAS,qBAAO,0CAAGtB;YAExB,sCAAsC;YACtC,qBAAO,oBAACmB,WAAeE;QACzB;QAEA,6CAA6C;QAC7C,MAAMG,gBAAgBL,UAAU,WAAW,IAAIA,UAAU,IAAI,IAAI;QACjEC,iBAAiB,WAAW,GAAG,CAAC,aAAa,EAAEI,cAAc,CAAC,CAAC;QAE/D,OAAOJ;IACT;IAEA,OAAO;QACL,eAAe;QACfF;QACAd;QAEA,qFAAqF;QACrF,cAAc,IAAMD,QAAQ,YAAY;QACxC,SAAS,IAAMA,QAAQ,OAAO;QAC9B,iBAAiB,IAAMA,QAAQ,eAAe;QAC9C,SAAS,CAACsB,KAA8CtB,QAAQ,OAAO,CAACsB;QACxE,SAAS,CAACA,KAA8CtB,QAAQ,OAAO,CAACsB;QACxE,WAAW,IAAMtB,QAAQ,SAAS;QAClC,UAAU,IAAMA,QAAQ,QAAQ;QAChC,SAAS,IAAMA,QAAQ,OAAO;IAChC;AACF"}

package/dist/react/utils/createSynapseCtx.d.ts

@@ -0,0 +1,33 @@
+import { ComponentType } from 'react';
+import { Observable } from 'rxjs';
+import { IStorage } from '../../core';
+import { SynapseStoreBasic, SynapseStoreWithDispatcher, SynapseStoreWithEffects } from '../../utils';
+interface SimplifiedOptions {
+    loadingComponent?: React.ReactNode;
+}
+/**
+ * Перегрузки для createSynapseCtx в зависимости от типа хранилища
+ */
+export declare function createSynapseCtx<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions>(synapseStorePromise: Promise<SynapseStoreWithEffects<TStore, TStorage, TSelectors, TActions>> | SynapseStoreWithEffects<TStore, TStorage, TSelectors, TActions>, options?: SimplifiedOptions): {
+    contextSynapse: <SelfComponentProps>(Component: ComponentType<SelfComponentProps>) => ComponentType<SelfComponentProps>;
+    useSynapseStorage: () => TStorage;
+    useSynapseSelectors: () => TSelectors;
+    useSynapseActions: () => TActions;
+    useSynapseState$: () => Observable<TStore>;
+    cleanupSynapse: () => Promise<void>;
+};
+export declare function createSynapseCtx<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions>(synapseStorePromise: Promise<SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, TActions>> | SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, TActions>, options?: SimplifiedOptions): {
+    contextSynapse: <SelfComponentProps>(Component: ComponentType<SelfComponentProps>) => ComponentType<SelfComponentProps>;
+    useSynapseStorage: () => TStorage;
+    useSynapseSelectors: () => TSelectors;
+    useSynapseActions: () => TActions;
+    cleanupSynapse: () => Promise<void>;
+};
+export declare function createSynapseCtx<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors>(synapseStorePromise: Promise<SynapseStoreBasic<TStore, TStorage, TSelectors>> | SynapseStoreBasic<TStore, TStorage, TSelectors>, options?: SimplifiedOptions): {
+    contextSynapse: <SelfComponentProps>(Component: ComponentType<SelfComponentProps>) => ComponentType<SelfComponentProps>;
+    useSynapseStorage: () => TStorage;
+    useSynapseSelectors: () => TSelectors;
+    cleanupSynapse: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=createSynapseCtx.d.ts.map

package/dist/react/utils/createSynapseCtx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSynapseCtx.d.ts","sourceRoot":"","sources":["../../../src/react/utils/createSynapseCtx.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAiF,MAAM,OAAO,CAAA;AACpH,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAGjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAmB,iBAAiB,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAKrH,UAAU,iBAAiB;IACzB,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CACnC;AAED;;GAEG;AAGH,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,QAAQ,EAC1H,mBAAmB,EAAE,OAAO,CAAC,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,EAC/J,OAAO,CAAC,EAAE,iBAAiB,GAC1B;IACD,cAAc,EAAE,CAAC,kBAAkB,EAAE,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACvH,iBAAiB,EAAE,MAAM,QAAQ,CAAA;IACjC,mBAAmB,EAAE,MAAM,UAAU,CAAA;IACrC,iBAAiB,EAAE,MAAM,QAAQ,CAAA;IACjC,gBAAgB,EAAE,MAAM,UAAU,CAAC,MAAM,CAAC,CAAA;IAC1C,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC,CAAA;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,QAAQ,EAC1H,mBAAmB,EAAE,OAAO,CAAC,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,EACrK,OAAO,CAAC,EAAE,iBAAiB,GAC1B;IACD,cAAc,EAAE,CAAC,kBAAkB,EAAE,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACvH,iBAAiB,EAAE,MAAM,QAAQ,CAAA;IACjC,mBAAmB,EAAE,MAAM,UAAU,CAAA;IACrC,iBAAiB,EAAE,MAAM,QAAQ,CAAA;IACjC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC,CAAA;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,EAChH,mBAAmB,EAAE,OAAO,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,EAC/H,OAAO,CAAC,EAAE,iBAAiB,GAC1B;IACD,cAAc,EAAE,CAAC,kBAAkB,EAAE,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACvH,iBAAiB,EAAE,MAAM,QAAQ,CAAA;IACjC,mBAAmB,EAAE,MAAM,UAAU,CAAA;IACrC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC,CAAA"}

package/dist/react/utils/createSynapseCtx.js

@@ -0,0 +1,139 @@
+import { createContext, forwardRef, useContext, useEffect, useState } from "react";
+import { handleCleanupError, handleOperationError } from "../../_utils/error-handling.util.js";
+
+
+
+
+
+const ERROR_HOOK_MESSAGE = 'Хук необходимо использовать внутри компонента contextSynapse';
+const ERROR_CONTEXT_INIT = 'Ошибка при инициализации контекста:';
+// Основная реализация
+function createSynapseCtx(synapseStorePromise, options) {
+    const { loadingComponent = /*#__PURE__*/ React.createElement("div", null, "Инициализация контекста...") } = options || {};
+    // Lazy-инициализация: Promise создаётся при первом обращении и сбрасывается при cleanup
+    let storeInitPromise = null;
+    const getStoreInitPromise = ()=>{
+        if (!storeInitPromise) {
+            storeInitPromise = (async ()=>{
+                try {
+                    const store = await (synapseStorePromise instanceof Promise ? synapseStorePromise : Promise.resolve(synapseStorePromise));
+                    await store.storage.waitForReady();
+                    return store;
+                } catch (error) {
+                    handleOperationError('createSynapseCtx: Synapse storage initialization error', error);
+                }
+            })();
+        }
+        return storeInitPromise;
+    };
+    const SynapseContext = /*#__PURE__*/ createContext(null);
+    const useSynapseStorage = ()=>{
+        const context = useContext(SynapseContext);
+        if (!context) throw new Error(`useSynapseStorage: ${ERROR_HOOK_MESSAGE}`);
+        return context.storage;
+    };
+    const useSynapseSelectors = ()=>{
+        const context = useContext(SynapseContext);
+        if (!context) throw new Error(`useSynapseSelectors: ${ERROR_HOOK_MESSAGE}`);
+        return context.selectors;
+    };
+    // Условный хук для actions (только если есть dispatcher)
+    const useSynapseActions = ()=>{
+        const context = useContext(SynapseContext);
+        if (!context) throw new Error(`useSynapseActions: ${ERROR_HOOK_MESSAGE}`);
+        if ('actions' in context) {
+            return context.actions;
+        }
+        throw new Error('useSynapseActions: actions недоступны для этого типа хранилища. Убедитесь, что передана функция createDispatcherFn при создании хранилища.');
+    };
+    // Условный хук для state$ (только если есть effects)
+    const useSynapseState$ = ()=>{
+        const context = useContext(SynapseContext);
+        if (!context) throw new Error(`useSynapseState$: ${ERROR_HOOK_MESSAGE}`);
+        if ('state$' in context) {
+            return context.state$;
+        }
+        throw new Error('useSynapseState$: state$ недоступен для этого типа хранилища. Убедитесь, что переданы функции createDispatcherFn и createEffectConfig при создании хранилища.');
+    };
+    /**
+   * Декоратор для обертывания компонентов в контекст Synapse
+   */ function contextSynapse(Component) {
+        const WrappedComponent = /*#__PURE__*/ forwardRef(function WrappedComponent(props, ref) {
+            const [synapseStore, setSynapseStore] = useState(null);
+            const [isReady, setIsReady] = useState(false);
+            const [error, setError] = useState(null);
+            useEffect(()=>{
+                let mounted = true;
+                const initializeContext = async ()=>{
+                    try {
+                        const store = await getStoreInitPromise();
+                        if (mounted) {
+                            setSynapseStore(store);
+                            setIsReady(true);
+                        }
+                    } catch (err) {
+                        if (mounted) {
+                            setError(err instanceof Error ? err : new Error(String(err)));
+                        }
+                    }
+                };
+                initializeContext();
+                return ()=>{
+                    mounted = false;
+                };
+            }, []);
+            // Показываем ошибку если что-то пошло не так
+            if (error) return /*#__PURE__*/ React.createElement("div", null, `${ERROR_CONTEXT_INIT}: ${error.message}`);
+            // Показываем загрузку пока все не готово
+            if (!isReady || !synapseStore) return /*#__PURE__*/ React.createElement(React.Fragment, null, loadingComponent);
+            return /*#__PURE__*/ React.createElement(SynapseContext.Provider, {
+                value: synapseStore
+            }, /*#__PURE__*/ React.createElement(Component, {
+                ...props,
+                ref: ref
+            }));
+        });
+        // Устанавливаем отображаемое имя для отладки
+        const componentName = Component.displayName || Component.name || 'Component';
+        WrappedComponent.displayName = `SynapseContext(${componentName})`;
+        // Копируем статические свойства оригинального компонента
+        const excludedKeys = new Set([
+            '$$typeof',
+            'render',
+            'defaultProps',
+            'displayName',
+            'propTypes'
+        ]);
+        Object.keys(Component).forEach((key)=>{
+            if (!excludedKeys.has(key)) {
+                ;
+                WrappedComponent[key] = Component[key];
+            }
+        });
+        return WrappedComponent;
+    }
+    const cleanupSynapse = async ()=>{
+        try {
+            if (storeInitPromise) {
+                const store = await storeInitPromise;
+                storeInitPromise = null;
+                return store?.destroy() || Promise.resolve();
+            }
+        } catch (error) {
+            storeInitPromise = null;
+            handleCleanupError('createSynapseCtx: error during Synapse cleanup', error);
+        }
+    };
+    return {
+        contextSynapse,
+        useSynapseStorage,
+        useSynapseSelectors,
+        useSynapseActions,
+        useSynapseState$,
+        cleanupSynapse
+    };
+}
+
+export { createSynapseCtx };
+
+//# sourceMappingURL=createSynapseCtx.js.map