synapse-storage 3.0.3 → 3.0.4

package/dist/utils.js

@@ -1,574 +1 @@
-// src/core/selector/selector.module.ts
-var DEBUG = false;
-var GLOBAL_SELECTOR_CACHE = /* @__PURE__ */ new Map();
-function getStringHash(str) {
-  let hash = 0;
-  if (str.length === 0) return hash.toString(36);
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return Math.abs(hash).toString(36).substring(0, 6);
-}
-function defaultEquals(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== "object" && typeof a !== "function" && typeof b !== "object" && typeof b !== "function") {
-    return a === b;
-  }
-  if (typeof a !== typeof b) return false;
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!defaultEquals(a[i], b[i])) return false;
-    }
-    return true;
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => {
-      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
-      return defaultEquals(a[key], b[key]);
-    });
-  }
-  return false;
-}
-function memoizeSelector(selectorFn, equals = defaultEquals) {
-  let lastState;
-  let lastResult;
-  let hasResult = false;
-  return function memoized(state) {
-    if (!hasResult || lastState !== state) {
-      const newResult = selectorFn(state);
-      if (!hasResult || !equals(newResult, lastResult)) {
-        lastResult = newResult;
-      }
-      lastState = state;
-      hasResult = true;
-    }
-    return lastResult;
-  };
-}
-var SelectorSubscription = class {
-  constructor(name, getState, equals = defaultEquals, logger) {
-    this.name = name;
-    this.equals = equals;
-    this.logger = logger;
-    this.id = name;
-    this.memoizedGetState = this.createMemoizedGetState(getState);
-    if (DEBUG) {
-      console.log(`[${this.id}] \u0421\u043E\u0437\u0434\u0430\u043D new SelectorSubscription`);
-    }
-  }
-  id;
-  subscribers = /* @__PURE__ */ new Set();
-  lastValue;
-  memoizedGetState;
-  // Создает мемоизированную версию getState с кешированием результата
-  createMemoizedGetState(getState) {
-    let lastPromise = null;
-    let isExecuting = false;
-    return async () => {
-      if (isExecuting && lastPromise) {
-        return lastPromise;
-      }
-      isExecuting = true;
-      try {
-        lastPromise = getState();
-        return await lastPromise;
-      } finally {
-        isExecuting = false;
-      }
-    };
-  }
-  async notify() {
-    try {
-      const newValue = await this.memoizedGetState();
-      if (this.lastValue === void 0 || !this.equals(newValue, this.lastValue)) {
-        if (DEBUG) {
-          console.log(`[${this.id}] \u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C, notify()`, {
-            old: this.lastValue,
-            new: newValue
-          });
-        }
-        this.lastValue = newValue;
-        const promises = Array.from(this.subscribers).map(async (subscriber) => {
-          try {
-            await subscriber.notify(newValue);
-          } catch (error) {
-            this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0430`, { error });
-          }
-        });
-        await Promise.all(promises);
-      } else if (DEBUG) {
-        console.log(`[${this.id}] \u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043D\u0435 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C in notify(), \u043F\u0440\u043E\u043F\u0443\u0441\u043A \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u044F`);
-      }
-    } catch (error) {
-      this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 notify()`, { error });
-      throw error;
-    }
-  }
-  subscribe(subscriber) {
-    if (DEBUG) {
-      console.log(`[${this.id}] \u0414\u043E\u0431\u0430\u0432\u043B\u0435\u043D\u043E \u043D\u043E\u0432\u044B\u0439 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A, \u0432\u0441\u0435\u0433\u043E: ${this.subscribers.size + 1}`);
-    }
-    this.subscribers.add(subscriber);
-    if (this.lastValue !== void 0) {
-      Promise.resolve().then(() => {
-        try {
-          subscriber.notify(this.lastValue);
-        } catch (error) {
-          this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u0435\u0440\u0432\u043E\u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438`, { error });
-        }
-      });
-    } else {
-      this.notify().catch((error) => {
-        this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u0435\u0440\u0432\u043E\u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438`, { error });
-      });
-    }
-    return () => {
-      if (DEBUG) {
-        console.log(`[${this.id}] \u041F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A \u0443\u0434\u0430\u043B\u0435\u043D, \u043E\u0441\u0442\u0430\u043B\u043E\u0441\u044C: ${this.subscribers.size - 1}`);
-      }
-      this.subscribers.delete(subscriber);
-    };
-  }
-  cleanup() {
-    if (DEBUG) {
-      console.log(`[${this.id}] \u041E\u0447\u0438\u0441\u0442\u043A\u0430 \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438, \u0431\u044B\u043B\u043E ${this.subscribers.size} \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u043E\u0432`);
-    }
-    this.subscribers.clear();
-    this.lastValue = void 0;
-  }
-  getId() {
-    return this.id;
-  }
-};
-var SelectorModule = class {
-  constructor(source, logger) {
-    this.source = source;
-    this.logger = logger;
-    this.storageName = source.name;
-    if (DEBUG) {
-      console.log(`\u0421\u043E\u0437\u0434\u0430\u043D SelectorModule \u0434\u043B\u044F \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430: ${this.storageName}`);
-    }
-    this.source.getState().then((state) => {
-      this.cachedState = state;
-      if (DEBUG) {
-        console.log(`\u041A\u044D\u0448\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E\u0435 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0434\u043B\u044F ${this.storageName}`);
-      }
-    });
-  }
-  storageName;
-  subscriptions = /* @__PURE__ */ new Map();
-  cachedState;
-  localSelectorCache = /* @__PURE__ */ new Map();
-  // Флаг для батчинга обновлений
-  batchUpdateInProgress = false;
-  pendingUpdates = /* @__PURE__ */ new Set();
-  /**
-   * Генерирует имя для селектора на основе его типа и функции
-   */
-  generateName(isSimpleSelector, selectorOrDeps, resultFnOrOptions) {
-    const type = isSimpleSelector ? "simple" : "combined";
-    let hash = "";
-    if (isSimpleSelector) {
-      const selectorStr = selectorOrDeps.toString();
-      hash = getStringHash(selectorStr);
-    } else {
-      const depsIds = selectorOrDeps.map((s) => s.getId()).join("_");
-      const resultFnStr = resultFnOrOptions.toString();
-      hash = getStringHash(depsIds + resultFnStr);
-    }
-    return `${this.storageName}_${type}_${hash}`;
-  }
-  /**
-   * Обрабатывает отложенные обновления, чтобы избежать каскадных уведомлений
-   */
-  processPendingUpdates() {
-    if (this.pendingUpdates.size === 0 || this.batchUpdateInProgress) return;
-    this.batchUpdateInProgress = true;
-    setTimeout(async () => {
-      try {
-        const subscriptionsToUpdate = Array.from(this.pendingUpdates);
-        this.pendingUpdates.clear();
-        this.cachedState = await this.source.getState();
-        const updatePromises = subscriptionsToUpdate.map(async (id) => {
-          const subscription = this.subscriptions.get(id);
-          if (subscription) {
-            try {
-              return await subscription.notify();
-            } catch (error) {
-              this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u044F \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0430 ${id}`, { error });
-            }
-          }
-          return Promise.resolve();
-        });
-        await Promise.all(updatePromises);
-      } catch (error) {
-        this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0438 \u043E\u0436\u0438\u0434\u0430\u044E\u0449\u0438\u0445 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0439", { error });
-      } finally {
-        this.batchUpdateInProgress = false;
-        if (this.pendingUpdates.size > 0) {
-          this.processPendingUpdates();
-        }
-      }
-    }, 0);
-  }
-  createSelector(selectorOrDeps, resultFnOrOptions, optionsArg) {
-    const isSimpleSelector = !Array.isArray(selectorOrDeps);
-    const options = isSimpleSelector ? resultFnOrOptions || {} : optionsArg || {};
-    const selectorId = options.name || this.generateName(isSimpleSelector, selectorOrDeps, isSimpleSelector ? void 0 : resultFnOrOptions);
-    if (this.localSelectorCache.has(selectorId)) {
-      if (DEBUG) {
-        console.log(`[${this.storageName}] Reusing cached selector: ${selectorId}`);
-      }
-      return this.localSelectorCache.get(selectorId).api;
-    }
-    if (GLOBAL_SELECTOR_CACHE.has(selectorId)) {
-      const cached = GLOBAL_SELECTOR_CACHE.get(selectorId);
-      cached.refCount++;
-      if (DEBUG) {
-        console.log(`[${this.storageName}] \u041F\u043E\u0432\u0442\u043E\u0440\u043D\u043E\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u044D\u0448\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E\u0433\u043E \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440\u0430: ${selectorId}, refCount: ${cached.refCount}`);
-      }
-      return cached.api;
-    }
-    let result;
-    let dependencies;
-    let unsubscribeFunctions = [];
-    if (isSimpleSelector) {
-      const memoized = memoizeSelector(selectorOrDeps, options.equals || defaultEquals);
-      const created = this.createSimpleSelector(memoized, { ...options, name: selectorId, equals: options.equals || defaultEquals });
-      result = created.api;
-      unsubscribeFunctions = created.unsubscribeFunctions;
-    } else {
-      dependencies = selectorOrDeps;
-      const created = this.createCombinedSelector(dependencies, resultFnOrOptions, {
-        ...options,
-        name: selectorId,
-        equals: options.equals || defaultEquals
-      });
-      result = created.api;
-      unsubscribeFunctions = created.unsubscribeFunctions;
-    }
-    this.localSelectorCache.set(selectorId, {
-      api: result,
-      dependencies,
-      unsubscribeFunctions
-    });
-    GLOBAL_SELECTOR_CACHE.set(selectorId, {
-      api: result,
-      refCount: 1,
-      unsubscribeFunctions
-    });
-    if (DEBUG) {
-      console.log(`[${this.storageName}] \u0421\u043E\u0437\u0434\u0430\u043D \u043D\u043E\u0432\u044B\u0439 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440: ${selectorId}`);
-    }
-    return result;
-  }
-  createSimpleSelector(selector, options) {
-    if (DEBUG) {
-      console.log(`[${this.storageName}] \u0421\u043E\u0437\u0434\u0430\u043D \u043F\u0440\u043E\u0441\u0442\u043E\u0439 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440: ${options.name}`);
-    }
-    const getState = async () => {
-      if (this.cachedState) {
-        return selector(this.cachedState);
-      }
-      const state = await this.source.getState();
-      this.cachedState = state;
-      return selector(state);
-    };
-    const subscription = new SelectorSubscription(options.name, getState, options.equals || defaultEquals, this.logger);
-    const id = subscription.getId();
-    this.subscriptions.set(id, subscription);
-    const unsubscribeFromStorage = this.source.subscribeToAll(async (event) => {
-      if (event?.type === "storage:update") {
-        if (DEBUG) {
-          console.log(`[${id}] \u041F\u043E\u043B\u0443\u0447\u0435\u043D\u043E \u0441\u043E\u0431\u044B\u0442\u0438\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430`);
-        }
-        this.pendingUpdates.add(id);
-        this.processPendingUpdates();
-      }
-    });
-    const unsubscribeFunctions = [unsubscribeFromStorage];
-    return {
-      api: {
-        select: () => getState(),
-        subscribe: (subscriber) => {
-          return subscription.subscribe(subscriber);
-        },
-        getId: () => id
-      },
-      unsubscribeFunctions
-    };
-  }
-  createCombinedSelector(selectors, resultFn, options) {
-    const memoizedResultFn = memoizeSelector((args) => resultFn(...args), options.equals || defaultEquals);
-    const getState = async () => {
-      const values = await Promise.all(selectors.map((s) => s.select()));
-      return memoizedResultFn(values);
-    };
-    const subscription = new SelectorSubscription(options.name, getState, options.equals || defaultEquals, this.logger);
-    const id = subscription.getId();
-    this.subscriptions.set(id, subscription);
-    let debounceTimer = null;
-    const triggerUpdate = () => {
-      if (debounceTimer !== null) {
-        clearTimeout(debounceTimer);
-      }
-      debounceTimer = setTimeout(() => {
-        debounceTimer = null;
-        subscription.notify().catch((error) => this.logger?.error(`[${id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043E\u0431\u044A\u0435\u0434\u0438\u043D\u0435\u043D\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438:`, { error }));
-      }, 10);
-    };
-    const unsubscribeFunctions = selectors.map(
-      (selector) => selector.subscribe({
-        notify: () => {
-          triggerUpdate();
-        }
-      })
-    );
-    return {
-      api: {
-        select: () => getState(),
-        subscribe: (subscriber) => {
-          return subscription.subscribe(subscriber);
-        },
-        getId: () => id
-      },
-      unsubscribeFunctions
-    };
-  }
-  destroy() {
-    if (DEBUG) {
-      console.log(`[${this.storageName}] \u041D\u0430\u0447\u0430\u043B\u043E\u0441\u044C \u0443\u043D\u0438\u0447\u0442\u043E\u0436\u0435\u043D\u0438\u0435 SelectorModule`);
-    }
-    this.subscriptions.forEach((sub) => sub.cleanup());
-    this.subscriptions.clear();
-    this.cachedState = void 0;
-    this.pendingUpdates.clear();
-    this.localSelectorCache.forEach((cached) => {
-      cached.unsubscribeFunctions.forEach((unsub) => unsub());
-    });
-    const keysToCheck = /* @__PURE__ */ new Set();
-    this.localSelectorCache.forEach((_, key) => {
-      keysToCheck.add(key);
-    });
-    this.localSelectorCache.clear();
-    keysToCheck.forEach((key) => {
-      const globalCached = GLOBAL_SELECTOR_CACHE.get(key);
-      if (globalCached) {
-        globalCached.refCount--;
-        if (globalCached.refCount <= 0) {
-          globalCached.unsubscribeFunctions.forEach((unsub) => unsub());
-          GLOBAL_SELECTOR_CACHE.delete(key);
-          if (DEBUG) {
-            console.log(`[${this.storageName}] \u0423\u0434\u0430\u043B\u0435\u043D \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440 \u0438\u0437 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u044D\u0448\u0430: ${key}`);
-          }
-        }
-      }
-    });
-    if (DEBUG) {
-      console.log(`[${this.storageName}] \u0423\u043D\u0438\u0447\u0442\u043E\u0436\u0435\u043D`);
-    }
-  }
-};
-
-// src/reactive/dispatcher/dispatcher.module.ts
-import { Subject } from "rxjs";
-
-// src/reactive/effects/effects.module.ts
-import { combineLatest, merge, Observable as Observable4, of as of2, pipe, Subject as Subject2 } from "rxjs";
-import { catchError, filter, map, share, switchMap, take } from "rxjs/operators";
-
-// src/reactive/effects/utils/chunkRequestConsistent.ts
-import { of } from "rxjs";
-import { concatAll, delay, mergeMap, toArray } from "rxjs/operators";
-
-// src/reactive/effects/utils/chunkRequestParallel.ts
-import { forkJoin, timer } from "rxjs";
-import { mergeMap as mergeMap2 } from "rxjs/operators";
-
-// src/reactive/effects/effects.module.ts
-var EffectsModule = class {
-  /**
-   * Создает модуль эффектов с доступом к состоянию, внешним состояниям и конфигурации
-   * @param storage Хранилище состояния
-   * @param externalStates Внешние состояния
-   * @param dispatchers Объект с диспетчерами
-   * @param services Объект с сервисами
-   * @param config Глобальная конфигурация для всех эффектов
-   */
-  constructor(storage, externalStates = {}, dispatchers, services = {}, config = {}) {
-    this.storage = storage;
-    this.externalStates = externalStates;
-    this.dispatchers = dispatchers;
-    this.services = services;
-    this.config = config;
-    this.subscribeToDispatchers();
-    this.state$ = new Observable4((observer) => {
-      this.storage.getState().then((state) => observer.next(state));
-      const unsubscribe = this.storage.subscribeToAll(() => {
-        this.storage.getState().then((state) => observer.next(state));
-      });
-      return () => unsubscribe();
-    }).pipe(share());
-  }
-  effects = [];
-  subscriptions = [];
-  running = false;
-  action$ = new Subject2();
-  /**
-   * Поток состояния
-   */
-  state$;
-  /**
-   * Подписывается на действия от всех диспетчеров
-   */
-  subscribeToDispatchers() {
-    for (const [_, dispatcher] of Object.entries(this.dispatchers)) {
-      const subscription = dispatcher.actions.subscribe((action) => {
-        this.action$.next(action);
-      });
-      this.subscriptions.push(subscription);
-    }
-  }
-  add(effect) {
-    this.effects.push(effect);
-    if (this.running) {
-      this.subscribeToEffect(effect);
-    }
-    return this;
-  }
-  /**
-   * Добавляет несколько эффектов
-   * @param effects Эффекты для добавления
-   * @returns Текущий модуль
-   */
-  addEffects(effects) {
-    effects.forEach((effect) => this.add(effect));
-    return this;
-  }
-  /**
-   * Запускает все эффекты
-   * @returns Текущий модуль
-   */
-  start() {
-    if (this.running) {
-      return this;
-    }
-    this.effects.forEach((effect) => this.subscribeToEffect(effect));
-    this.running = true;
-    return this;
-  }
-  /**
-   * Останавливает все эффекты
-   * @returns Текущий модуль
-   */
-  stop() {
-    this.subscriptions.forEach((sub) => sub.unsubscribe());
-    this.subscriptions = [];
-    this.running = false;
-    return this;
-  }
-  /**
-   * Подписывается на конкретный эффект
-   * @param effect Эффект для подписки
-   */
-  subscribeToEffect(effect) {
-    try {
-      const output$ = effect(this.action$.asObservable(), this.state$, this.externalStates, this.dispatchers, this.services, this.config).pipe(
-        catchError((err) => {
-          console.error("Error in effect:", err);
-          return of2(null);
-        })
-      );
-      const subscription = output$.subscribe((result) => {
-        if (result === null || result === void 0) {
-          return;
-        }
-        if (typeof result === "function") {
-          try {
-            result();
-          } catch (callError) {
-            console.error("Error calling effect result function:", callError);
-          }
-        }
-      });
-      this.subscriptions.push(subscription);
-    } catch (setupError) {
-      console.error("Error setting up effect:", setupError);
-    }
-  }
-};
-
-// src/utils/createSynapse.ts
-async function createSynapse(config) {
-  const storageInstance = config.createStorageFn ? await config.createStorageFn() : config.storage;
-  const cleanupCallbacks = [];
-  const result = {
-    storage: storageInstance,
-    selectors: {},
-    destroy: async () => {
-      for (const callback of cleanupCallbacks) {
-        await callback();
-      }
-    }
-  };
-  cleanupCallbacks.push(() => storageInstance.destroy());
-  let dispatcher;
-  let selectorModule;
-  let effectsModule;
-  if (config.createSelectorsFn) {
-    try {
-      selectorModule = new SelectorModule(storageInstance);
-      const externalSelectors = config.externalSelectors || {};
-      result.selectors = config.createSelectorsFn(selectorModule, externalSelectors);
-      if (typeof selectorModule.destroy === "function") {
-        cleanupCallbacks.push(() => selectorModule.destroy());
-      }
-    } catch (error) {
-      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F selectors:", error);
-    }
-  }
-  if (config.createDispatcherFn) {
-    dispatcher = config.createDispatcherFn(storageInstance);
-    result.dispatcher = dispatcher;
-    if (dispatcher && "dispatch" in dispatcher) {
-      result.actions = dispatcher.dispatch;
-      if (typeof dispatcher.destroy === "function") {
-        cleanupCallbacks.push(() => dispatcher.destroy());
-      }
-    }
-  }
-  if (config.createEffectConfig && dispatcher) {
-    try {
-      const { dispatchers, api, config: effectConfig, externalStates } = config.createEffectConfig(dispatcher);
-      const effectExternalStates = externalStates || {};
-      effectsModule = new EffectsModule(storageInstance, effectExternalStates, dispatchers, api, effectConfig);
-      if (Array.isArray(config.effects)) {
-        config.effects.forEach((effect) => {
-          if (effectsModule) effectsModule.add(effect);
-        });
-      }
-      effectsModule.start();
-      result.state$ = effectsModule.state$;
-      cleanupCallbacks.push(() => {
-        if (effectsModule) effectsModule.stop();
-      });
-    } catch (error) {
-      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F \u043C\u043E\u0434\u0443\u043B\u044F \u044D\u0444\u0444\u0435\u043A\u0442\u043E\u0432:", error);
-    }
-  }
-  return result;
-}
-export {
-  createSynapse
-};
-//# sourceMappingURL=utils.js.map
+export{a as createSynapse}from'./chunk-WQNH3LVB.js';import'./chunk-6RNZVHSR.js';import'./chunk-IPUPRMZK.js';import'./chunk-ZE2EJX2Y.js';import'./chunk-5X65PSGD.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synapse-storage",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "Набор инструментов для управления состоянием и апи-запросами",
   "type": "module",
   "main": "./dist/index.cjs",