synapse-storage 3.0.1 → 3.0.3

package/dist/utils.cjs

@@ -0,0 +1,601 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  createSynapse: () => createSynapse
+});
+module.exports = __toCommonJS(utils_exports);
+
+// 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
+var import_rxjs = require("rxjs");
+
+// src/reactive/effects/effects.module.ts
+var import_rxjs4 = require("rxjs");
+var import_operators3 = require("rxjs/operators");
+
+// src/reactive/effects/utils/chunkRequestConsistent.ts
+var import_rxjs2 = require("rxjs");
+var import_operators = require("rxjs/operators");
+
+// src/reactive/effects/utils/chunkRequestParallel.ts
+var import_rxjs3 = require("rxjs");
+var import_operators2 = require("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 import_rxjs4.Observable((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((0, import_operators3.share)());
+  }
+  effects = [];
+  subscriptions = [];
+  running = false;
+  action$ = new import_rxjs4.Subject();
+  /**
+   * Поток состояния
+   */
+  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(
+        (0, import_operators3.catchError)((err) => {
+          console.error("Error in effect:", err);
+          return (0, import_rxjs4.of)(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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSynapse
+});
+//# sourceMappingURL=utils.cjs.map