synapse-storage 3.0.3 → 3.0.5

package/dist/index.cjs

@@ -1,4148 +1 @@
-"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/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ApiClient: () => ApiClient,
-  Dispatcher: () => Dispatcher,
-  EffectsModule: () => EffectsModule,
-  IndexedDBStorage: () => IndexedDBStorage,
-  LocalStorage: () => LocalStorage,
-  MemoryStorage: () => MemoryStorage,
-  ResponseFormat: () => ResponseFormat,
-  SelectorModule: () => SelectorModule,
-  StorageEvents: () => StorageEvents,
-  StoragePluginModule: () => StoragePluginModule,
-  apiLogger: () => apiLogger,
-  broadcastMiddleware: () => broadcastMiddleware,
-  combineEffects: () => combineEffects,
-  createDispatcher: () => createDispatcher,
-  createEffect: () => createEffect,
-  createEffectBase: () => createEffectBase,
-  createSynapse: () => createSynapse,
-  createSynapseCtx: () => createSynapseCtx,
-  createUniqueId: () => createUniqueId,
-  headersToObject: () => headersToObject,
-  loggerDispatcherMiddleware: () => loggerDispatcherMiddleware,
-  ofType: () => ofType,
-  ofTypes: () => ofTypes,
-  ofTypesWaitAll: () => ofTypesWaitAll,
-  selectorMap: () => selectorMap,
-  selectorObject: () => selectorObject,
-  useSelector: () => useSelector,
-  useStorageSubscribe: () => useStorageSubscribe,
-  validateMap: () => validateMap
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/api/utils/api-helpers.ts
-var apiLogger = {
-  debug: (message, ...args) => {
-    if (process.env.NODE_ENV !== "production") {
-      console.debug(`[API] ${message}`, ...args);
-    }
-  },
-  log: (message, ...args) => {
-    if (process.env.NODE_ENV !== "production") {
-      console.log(`[API] ${message}`, ...args);
-    }
-  },
-  info: (message, ...args) => {
-    console.info(`[API] ${message}`, ...args);
-  },
-  warn: (message, ...args) => {
-    console.warn(`[API] ${message}`, ...args);
-  },
-  error: (message, ...args) => {
-    console.error(`[API] ${message}`, ...args);
-  }
-};
-function createUniqueId(name) {
-  return `${name ? `${name}|` : ""}${Math.random().toString(36).substring(2, 9) + Date.now().toString(36)}`;
-}
-function headersToObject(headers) {
-  const result = {};
-  headers.forEach((value, key) => {
-    result[key.toLowerCase()] = value;
-  });
-  return result;
-}
-
-// src/api/utils/create-header-context.ts
-function createHeaderContext(context = {}, optionContext = {}) {
-  return {
-    ...context,
-    ...optionContext,
-    getFromStorage: context.getFromStorage || ((key) => {
-      try {
-        const item = localStorage.getItem(key);
-        return item ? JSON.parse(item) : void 0;
-      } catch (error) {
-        console.warn(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F \u0438\u0437 localStorage: ${error}`);
-        return void 0;
-      }
-    }),
-    getCookie: context.getCookie || ((name) => {
-      try {
-        const matches = document.cookie.match(new RegExp(`(?:^|; )${name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, "\\$1")}=([^;]*)`));
-        return matches ? decodeURIComponent(matches[1]) : void 0;
-      } catch (error) {
-        console.warn(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F cookie: ${error}`);
-        return void 0;
-      }
-    })
-  };
-}
-
-// src/api/utils/endpoint-headers.ts
-async function prepareRequestHeaders(prepareHeadersFn, context) {
-  let headers = new Headers();
-  const headerContext = context || createHeaderContext({}, {});
-  if (prepareHeadersFn) {
-    try {
-      headers = await Promise.resolve(prepareHeadersFn(headers, headerContext));
-    } catch (error) {
-      console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432", error);
-    }
-  }
-  return headers;
-}
-function createPrepareHeaders(globalPrepareHeaders, endpointPrepareHeaders) {
-  return async (headers, context) => {
-    let processedHeaders = new Headers(headers);
-    if (globalPrepareHeaders) {
-      try {
-        processedHeaders = await Promise.resolve(globalPrepareHeaders(processedHeaders, context));
-      } catch (error) {
-        console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u044B\u0445 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432", error);
-      }
-    }
-    if (endpointPrepareHeaders) {
-      try {
-        processedHeaders = await Promise.resolve(endpointPrepareHeaders(processedHeaders, context));
-      } catch (error) {
-        console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432 \u044D\u043D\u0434\u043F\u043E\u0438\u043D\u0442\u0430", error);
-      }
-    }
-    return processedHeaders;
-  };
-}
-
-// src/api/types/api.interface.ts
-var ResponseFormat = /* @__PURE__ */ ((ResponseFormat2) => {
-  ResponseFormat2["Json"] = "json";
-  ResponseFormat2["Blob"] = "blob";
-  ResponseFormat2["ArrayBuffer"] = "arrayBuffer";
-  ResponseFormat2["Text"] = "text";
-  ResponseFormat2["FormData"] = "formData";
-  ResponseFormat2["Raw"] = "raw";
-  return ResponseFormat2;
-})(ResponseFormat || {});
-
-// src/api/utils/file-utils.ts
-function getResponseFormatForMimeType(contentType) {
-  const type = contentType.toLowerCase().split(";")[0].trim();
-  if (type.includes("application/json")) {
-    return "json" /* Json */;
-  }
-  if (type.includes("text/")) {
-    return "text" /* Text */;
-  }
-  if (type.includes("multipart/form-data")) {
-    return "formData" /* FormData */;
-  }
-  if (type.includes("application/octet-stream") || type.includes("application/pdf") || type.includes("image/") || type.includes("audio/") || type.includes("video/")) {
-    return "blob" /* Blob */;
-  }
-  return void 0;
-}
-function isFileResponse(headers) {
-  const contentType = headers.get("content-type") || "";
-  const contentDisposition = headers.get("content-disposition") || "";
-  const isFileContentType = contentType.includes("application/octet-stream") || contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("audio/") || contentType.includes("video/");
-  const isAttachment = contentDisposition.includes("attachment") || contentDisposition.includes("filename=");
-  return isFileContentType || isAttachment;
-}
-function extractFilenameFromHeaders(headers) {
-  const contentDisposition = headers.get("content-disposition");
-  if (!contentDisposition) return void 0;
-  const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
-  if (filenameMatch && filenameMatch[1]) {
-    return filenameMatch[1].replace(/['"]/g, "").trim();
-  }
-  return void 0;
-}
-function getFileMetadataFromHeaders(headers) {
-  const contentType = headers.get("content-type") || "";
-  const contentDisposition = headers.get("content-disposition") || "";
-  const contentLength = headers.get("content-length");
-  if (!isFileResponse(headers)) {
-    return void 0;
-  }
-  const filename = extractFilenameFromHeaders(headers);
-  return {
-    filename,
-    contentType,
-    contentDisposition,
-    size: contentLength ? parseInt(contentLength, 10) : void 0
-  };
-}
-
-// src/api/utils/fetch-base-query.ts
-async function getResponseData(response, format) {
-  let responseFormat = format;
-  const contentType = response.headers.get("content-type") || "";
-  if (!responseFormat && contentType) {
-    if (isFileResponse(response.headers)) {
-      responseFormat = "blob" /* Blob */;
-    } else {
-      responseFormat = getResponseFormatForMimeType(contentType);
-    }
-  }
-  if (!responseFormat) {
-    responseFormat = "json" /* Json */;
-  }
-  try {
-    let fileMetadata;
-    if (responseFormat === "blob" /* Blob */ || responseFormat === "arrayBuffer" /* ArrayBuffer */) {
-      fileMetadata = getFileMetadataFromHeaders(response.headers);
-    }
-    switch (responseFormat) {
-      case "json" /* Json */: {
-        try {
-          const data = await response.json();
-          return response.ok ? { data, fileMetadata } : { error: data, fileMetadata };
-        } catch (error) {
-          const text = await response.text();
-          return response.ok ? { data: text, fileMetadata } : { error: text, fileMetadata };
-        }
-      }
-      case "text" /* Text */: {
-        const text = await response.text();
-        return response.ok ? { data: text, fileMetadata } : { error: text, fileMetadata };
-      }
-      case "blob" /* Blob */: {
-        const blob2 = await response.blob();
-        return response.ok ? { data: blob2, fileMetadata } : { error: blob2, fileMetadata };
-      }
-      case "arrayBuffer" /* ArrayBuffer */: {
-        const buffer = await response.arrayBuffer();
-        return response.ok ? { data: buffer, fileMetadata } : { error: buffer, fileMetadata };
-      }
-      case "formData" /* FormData */: {
-        const formData = await response.formData();
-        return response.ok ? { data: formData, fileMetadata } : { error: formData, fileMetadata };
-      }
-      case "raw" /* Raw */: {
-        return response.ok ? { data: response, fileMetadata } : { error: response, fileMetadata };
-      }
-      default:
-        const blob = await response.blob();
-        return response.ok ? { data: blob, fileMetadata } : { error: blob, fileMetadata };
-    }
-  } catch (err) {
-    console.error(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u0437\u0432\u043B\u0435\u0447\u0435\u043D\u0438\u044F \u0434\u0430\u043D\u043D\u044B\u0445 \u0438\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 (\u0444\u043E\u0440\u043C\u0430\u0442: ${responseFormat})`, err);
-    return response.ok ? { data: void 0 } : { error: err };
-  }
-}
-function fetchBaseQuery(options) {
-  const { baseUrl, timeout = 3e4, fetchFn = fetch, credentials = "same-origin" } = options;
-  return async (args, queryOptions = {}, headers) => {
-    const { path, method, body, query, responseFormat: reqResponseFormat } = args;
-    const { signal, timeout: requestTimeout = timeout, responseFormat: optResponseFormat } = queryOptions;
-    const responseFormat = optResponseFormat || reqResponseFormat;
-    const url = new URL(path.startsWith("http") ? path : `${baseUrl}${path}`);
-    if (query) {
-      Object.entries(query).forEach(([key, value]) => {
-        if (value !== void 0 && value !== null) {
-          if (Array.isArray(value)) {
-            value.forEach((item) => url.searchParams.append(key, String(item)));
-          } else {
-            url.searchParams.append(key, String(value));
-          }
-        }
-      });
-    }
-    let serializedBody;
-    if (body !== void 0) {
-      if (body instanceof FormData || body instanceof Blob) {
-        serializedBody = body;
-      } else if (typeof body === "object" && body !== null) {
-        try {
-          serializedBody = JSON.stringify(body);
-          if (!headers.has("Content-Type")) {
-            headers.set("Content-Type", "application/json");
-          }
-        } catch (error) {
-          console.error("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u0435\u0440\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0442\u0435\u043B\u0430 \u0437\u0430\u043F\u0440\u043E\u0441\u0430", error);
-          serializedBody = String(body);
-        }
-      } else {
-        serializedBody = String(body);
-      }
-    }
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      if (requestTimeout) {
-        timeoutId = window.setTimeout(() => {
-          reject(new Error(`\u041F\u0440\u0435\u0432\u044B\u0448\u0435\u043D\u043E \u0432\u0440\u0435\u043C\u044F \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u044F \u0437\u0430\u043F\u0440\u043E\u0441\u0430 (${requestTimeout}\u043C\u0441)`));
-        }, requestTimeout);
-      }
-    });
-    try {
-      const fetchPromise = fetchFn(url.toString(), {
-        method,
-        headers,
-        body: serializedBody,
-        signal,
-        credentials
-      });
-      const response = await Promise.race([fetchPromise, timeoutPromise]);
-      const { data, error, fileMetadata } = await getResponseData(response, responseFormat);
-      const result = {
-        data,
-        error,
-        ok: response.ok,
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-        fileDownloadResult: fileMetadata
-      };
-      return result;
-    } catch (err) {
-      const error = err;
-      console.error("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F \u0437\u0430\u043F\u0440\u043E\u0441\u0430", error);
-      return {
-        error,
-        ok: false,
-        status: 0,
-        statusText: error.message,
-        headers: new Headers()
-      };
-    } finally {
-      if (timeoutId) {
-        window.clearTimeout(timeoutId);
-      }
-    }
-  };
-}
-
-// src/api/utils/get-cacheable-headers.ts
-function getCacheableHeaders(headers, cacheableHeaders = []) {
-  const result = {};
-  if (!headers || cacheableHeaders.length === 0) {
-    return result;
-  }
-  cacheableHeaders.forEach((key) => {
-    if (headers.has(key)) {
-      result[key] = headers.get(key) || "";
-    }
-  });
-  return result;
-}
-
-// src/api/components/endpoint.ts
-var EndpointClass = class {
-  constructor(name, queryStorage, configCurrentEndpoint, cacheableHeaderKeys, globalCacheConfig, baseQueryConfig) {
-    this.name = name;
-    this.queryStorage = queryStorage;
-    this.configCurrentEndpoint = configCurrentEndpoint;
-    this.cacheableHeaderKeys = cacheableHeaderKeys;
-    this.globalCacheConfig = globalCacheConfig;
-    this.baseQueryConfig = baseQueryConfig;
-    this.prepareHeaders = createPrepareHeaders(baseQueryConfig.prepareHeaders, configCurrentEndpoint.prepareHeaders);
-    this.queryFunction = fetchBaseQuery({
-      baseUrl: baseQueryConfig.baseUrl,
-      fetchFn: baseQueryConfig.fetchFn,
-      timeout: baseQueryConfig.timeout,
-      credentials: baseQueryConfig.credentials
-    });
-    this.cacheableHeaders = [...cacheableHeaderKeys || [], ...configCurrentEndpoint.includeCacheableHeaderKeys || []].filter(
-      (key) => !configCurrentEndpoint.excludeCacheableHeaderKeys?.includes(key)
-    );
-    this.meta.name = name;
-    this.meta.tags = configCurrentEndpoint.tags ?? this.meta.tags;
-    this.meta.invalidatesTags = configCurrentEndpoint.invalidatesTags ?? this.meta.invalidatesTags;
-    this.meta.cache = this.queryStorage.createCacheConfig(this.configCurrentEndpoint) ?? this.meta.cache;
-  }
-  endpointSubscribers = /* @__PURE__ */ new Set();
-  /** Сколько раз был вызван метод request */
-  fetchCounts = 0;
-  meta = {
-    cache: false,
-    invalidatesTags: [],
-    name: "",
-    tags: []
-  };
-  queryFunction;
-  /** Массив заголовков, которые нужно включить в ключ кэширования */
-  cacheableHeaders;
-  prepareHeaders;
-  request(params, options) {
-    this.fetchCounts++;
-    const requestId = createUniqueId(this.name);
-    const controller = new AbortController();
-    const requestSubscribers = /* @__PURE__ */ new Set();
-    const currentState = {
-      status: "idle",
-      requestParams: params,
-      headers: {},
-      error: void 0,
-      data: void 0,
-      fromCache: false
-    };
-    const headerContext = createHeaderContext({ requestParams: params }, options?.context || {});
-    const notifyRequestSubscribers = (newState) => {
-      Object.assign(currentState, newState);
-      requestSubscribers.forEach((cb) => {
-        cb({ ...currentState });
-      });
-    };
-    const waitPromise = new Promise(async (resolve, reject) => {
-      try {
-        const headers = await prepareRequestHeaders(this.prepareHeaders, headerContext);
-        const headersForCache = getCacheableHeaders(headers, options?.cacheableHeaderKeys ? options.cacheableHeaderKeys : this.cacheableHeaders);
-        const shouldCache = this.queryStorage.shouldCache(this.configCurrentEndpoint, options);
-        const [cacheKey, cacheParams] = this.queryStorage.createCacheKey(this.name, { ...params, ...headersForCache });
-        let cachedResult;
-        if (shouldCache) {
-          cachedResult = await this.queryStorage.getCachedResult(cacheKey);
-        }
-        if (cachedResult) {
-          notifyRequestSubscribers({
-            fromCache: true,
-            status: "success",
-            data: cachedResult.data,
-            error: void 0,
-            headers: cachedResult.headers,
-            requestParams: params
-          });
-          resolve({
-            ...cachedResult,
-            fromCache: true
-          });
-        } else {
-          notifyRequestSubscribers({
-            fromCache: false,
-            status: "loading"
-          });
-          const requestDefinition = this.configCurrentEndpoint.request(params, options?.context);
-          const mergedOptions = { ...options, signal: controller.signal };
-          const response = await this.queryFunction(requestDefinition, mergedOptions, headers);
-          if (response.ok) {
-            const { headers: headers2, ...restResponse } = response;
-            if (shouldCache) {
-              const currentCacheConfig = this.queryStorage.createCacheConfig(this.configCurrentEndpoint);
-              await this.queryStorage.setCachedResult(
-                cacheKey,
-                { ...restResponse, headers: headersToObject(headers2) },
-                currentCacheConfig,
-                cacheParams ?? {},
-                this.configCurrentEndpoint.tags ?? [],
-                this.configCurrentEndpoint.invalidatesTags ?? []
-              );
-            }
-            notifyRequestSubscribers({
-              fromCache: false,
-              status: "success",
-              data: response.data,
-              error: void 0,
-              headers: response.headers,
-              requestParams: params
-            });
-            this.endpointSubscribers.forEach((cb) => {
-              const endpointState = {
-                status: "success",
-                fetchCounts: this.fetchCounts,
-                meta: this.meta,
-                cacheableHeaders: this.cacheableHeaders,
-                error: void 0
-              };
-              cb(endpointState);
-            });
-            resolve({
-              ...response,
-              fromCache: false
-            });
-          } else {
-            notifyRequestSubscribers({
-              fromCache: false,
-              status: "error",
-              data: void 0,
-              error: response.error,
-              headers: response.headers,
-              requestParams: params
-            });
-            this.endpointSubscribers.forEach((cb) => {
-              const endpointState = {
-                status: "error",
-                fetchCounts: this.fetchCounts,
-                meta: this.meta,
-                cacheableHeaders: this.cacheableHeaders,
-                error: response.error
-              };
-              cb(endpointState);
-            });
-            reject(response.error);
-          }
-        }
-      } catch (error) {
-        notifyRequestSubscribers({
-          fromCache: false,
-          status: "error",
-          data: void 0,
-          error,
-          headers: void 0,
-          requestParams: params
-        });
-        reject(error);
-      }
-    });
-    return {
-      id: requestId,
-      subscribe(listener, options2 = {}) {
-        const { autoUnsubscribe = true } = options2;
-        requestSubscribers.add(listener);
-        listener(currentState);
-        const unsubscribe = () => requestSubscribers.delete(listener);
-        if (autoUnsubscribe) {
-          waitPromise.finally(() => {
-            unsubscribe();
-          });
-        }
-        return unsubscribe;
-      },
-      wait: () => waitPromise,
-      waitWithCallbacks(handlers = {}) {
-        const { idle, loading, success, error } = handlers;
-        this.subscribe(
-          (state) => {
-            switch (state.status) {
-              case "idle":
-                idle?.(state);
-                break;
-              case "loading":
-                loading?.(state);
-                break;
-              case "success":
-                success?.(state.data, state);
-                break;
-              case "error":
-                error?.(state.error, state);
-                break;
-            }
-          },
-          { autoUnsubscribe: true }
-        );
-        return waitPromise;
-      },
-      abort: () => {
-        if (controller && !controller.signal.aborted) {
-          controller.abort();
-        }
-      },
-      then: (onfulfilled, onrejected) => waitPromise.then(onfulfilled, onrejected),
-      catch: (onrejected) => waitPromise.catch(onrejected),
-      finally: (onfinally) => waitPromise.finally(onfinally)
-    };
-  }
-  subscribe(cb) {
-    this.endpointSubscribers.add(cb);
-    const currentState = {
-      status: "idle",
-      fetchCounts: this.fetchCounts,
-      meta: this.meta,
-      cacheableHeaders: this.cacheableHeaders,
-      error: void 0
-    };
-    cb(currentState);
-    return () => this.endpointSubscribers.delete(cb);
-  }
-  reset() {
-    this.fetchCounts = 0;
-    return Promise.resolve();
-  }
-  destroy() {
-    this.endpointSubscribers.clear();
-  }
-};
-
-// src/core/storage/utils/storage-key.ts
-var StorageKey = class {
-  constructor(value, isRawKey = false) {
-    this.value = value;
-    this.isRawKey = isRawKey;
-  }
-  toString() {
-    return this.value;
-  }
-  toJSON() {
-    return this.value;
-  }
-  valueOf() {
-    return this.value;
-  }
-  isUnparseable() {
-    return this.isRawKey;
-  }
-};
-
-// src/core/storage/utils/cache.util.ts
-var CacheUtils = class {
-  static createMetadata(ttl = 0, tags = []) {
-    const now = Date.now();
-    const expiresAt = ttl > 0 ? now + ttl : Infinity;
-    return {
-      createdAt: now,
-      updatedAt: now,
-      expiresAt,
-      tags,
-      createdAtDateTime: this.formatDateTime(now),
-      updatedAtDateTime: this.formatDateTime(now),
-      expiresAtDateTime: expiresAt === Infinity ? "never" : this.formatDateTime(expiresAt)
-    };
-  }
-  static formatDateTime(timestamp) {
-    return new Date(timestamp).toISOString();
-  }
-  static isExpired(metadata) {
-    return Date.now() > metadata.expiresAt;
-  }
-  static updateMetadata(metadata) {
-    return {
-      ...metadata,
-      updatedAt: Date.now()
-    };
-  }
-  static createKey(...parts) {
-    return new StorageKey(parts.join("_"));
-  }
-  static createApiKey(endpoint, params) {
-    if (!params) return [new StorageKey(endpoint, true), params];
-    const sortedParams = Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("&");
-    return [new StorageKey(`${endpoint}_${sortedParams}`, true), params];
-  }
-  // Функция для проверки, есть ли у записи определенные теги
-  static hasAnyTag(metadata, tags = []) {
-    if (!metadata.tags || !tags.length) return false;
-    return tags.some((tag) => metadata.tags?.includes(tag));
-  }
-};
-
-// src/api/components/query-storage.ts
-var QueryStorage = class {
-  constructor(storageExternal, globalCacheConfig) {
-    this.storageExternal = storageExternal;
-    this.globalCacheConfig = globalCacheConfig;
-  }
-  /** Экземпляр хранилища */
-  storage = null;
-  cleanupInterval = null;
-  /** Настройки кэша по умолчанию */
-  defaultCacheOptions = {
-    ttl: 5 * 60 * 1e3,
-    // 5 минут по умолчанию
-    cleanup: {
-      enabled: true,
-      interval: 10 * 60 * 1e3
-      // 10 минут
-    },
-    invalidateOnError: true
-  };
-  async initialize() {
-    await this.createStorage();
-    this.startCleanupInterval();
-    return this;
-  }
-  async createStorage() {
-    try {
-      const s = this.storageExternal;
-      await s.initialize();
-      this.storage = s;
-    } catch (error) {
-      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430", error);
-      throw error;
-    }
-  }
-  startCleanupInterval() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    const cleanupConfig = typeof this.globalCacheConfig === "object" ? this.globalCacheConfig.cleanup : this.defaultCacheOptions.cleanup;
-    if (cleanupConfig?.enabled && cleanupConfig.interval) {
-      this.cleanupInterval = setInterval(() => {
-        this.cleanup().catch((err) => console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u0447\u0438\u0441\u0442\u043A\u0435 \u043A\u044D\u0448\u0430:", err));
-      }, cleanupConfig.interval);
-    }
-  }
-  /**
-   * Получает экземпляр хранилища
-   */
-  getStorage() {
-    return this.storage;
-  }
-  /**
-   * Создает ключ кэша для запроса с учетом заголовков
-   * @param endpoint Имя эндпоинта
-   * @param params Параметры запроса (все что посчитаем нужным)
-   */
-  createCacheKey(endpoint, params) {
-    return CacheUtils.createApiKey(endpoint, params);
-  }
-  /**
-   * Получает результат запроса из кэша
-   */
-  async getCachedResult(cacheKey) {
-    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
-    const cachedEntry = await this.storage.get(cacheKey);
-    if (!cachedEntry) return void 0;
-    if (CacheUtils.isExpired(cachedEntry.metadata)) {
-      await this.storage.delete(cacheKey);
-      return void 0;
-    }
-    const updatedEntry = {
-      ...cachedEntry,
-      metadata: CacheUtils.updateMetadata(cachedEntry.metadata)
-    };
-    await this.storage.set(cacheKey, updatedEntry);
-    return cachedEntry.data;
-  }
-  /**
-   * Сохраняет результат запроса в кэш
-   * @param cacheKey Ключ кэша
-   * @param data Данные для кэширования
-   * @param cacheOptions Метаданные
-   * @param cacheParams Параметры которые влияли на созадние ключа
-   * @param tags Тэги эндпоинта
-   * @param invalidatesTags Тэги которые нужно инвалидировать
-   */
-  async setCachedResult(cacheKey, data, cacheOptions, cacheParams, tags, invalidatesTags) {
-    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
-    if (invalidatesTags?.length) {
-      await this.invalidateCacheByTags(invalidatesTags);
-    }
-    const cacheMetadata = CacheUtils.createMetadata(cacheOptions.ttl, tags);
-    const cacheEntry = {
-      data,
-      metadata: cacheMetadata,
-      params: cacheParams
-    };
-    await this.storage.set(cacheKey, cacheEntry);
-  }
-  /**
-   * Проверяет, должен ли запрос быть кэширован
-   * @param endpointConfig Конфигурация эндпоинта
-   * @param options Опции запроса
-   * @returns true если запрос должен кэшироваться
-   */
-  shouldCache(endpointConfig, options) {
-    if (this.globalCacheConfig === false) return false;
-    if (endpointConfig?.cache === false) return false;
-    if (typeof endpointConfig?.cache === "object" && endpointConfig?.cache.ttl === 0) return false;
-    if (options?.disableCache === true) return false;
-    if (this.globalCacheConfig === void 0 && endpointConfig?.cache === void 0) return false;
-    return true;
-  }
-  /**
-   * Создает итоговую конфигурацию кэширования для конкретного эндпоинта
-   * Объединяет глабальный конфиг с текущим
-   * @param endpointConfig Конфигурация эндпоинта
-   */
-  createCacheConfig(endpointConfig) {
-    let resultConfig = this.defaultCacheOptions;
-    if (typeof this.globalCacheConfig === "object") {
-      resultConfig = this.globalCacheConfig;
-    }
-    if (typeof endpointConfig?.cache === "object") {
-      const endpointCache = endpointConfig.cache;
-      resultConfig = {
-        // @ts-ignore
-        ...resultConfig,
-        ...endpointCache
-      };
-    }
-    return resultConfig;
-  }
-  /**
-   * Инвалидирует кэш по тегам
-   * @param tags Теги для инвалидации
-   */
-  async invalidateCacheByTags(tags) {
-    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
-    const keys = await this.storage.keys();
-    for (const key of keys) {
-      const cachedEntry = await this.storage.get(key);
-      if (cachedEntry && CacheUtils.hasAnyTag(cachedEntry.metadata, tags)) {
-        await this.storage.delete(key);
-      }
-    }
-  }
-  /**
-   * Инвалидирует кэш по ключу
-   * @param cacheKey Ключ кэша
-   */
-  async invalidateCache(cacheKey) {
-    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
-    await this.storage.delete(cacheKey);
-  }
-  /**
-   * Выполняет очистку всех просроченных записей кэша
-   */
-  async cleanup() {
-    if (!this.storage) {
-      throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
-    }
-    const keys = await this.storage.keys();
-    for (const key of keys) {
-      const value = await this.storage.get(key);
-      if (value && CacheUtils.isExpired(value.metadata)) {
-        await this.storage.delete(key);
-      }
-    }
-  }
-  /**
-   * Уничтожает хранилище и освобождает ресурсы
-   */
-  async destroy() {
-    if (this.cleanupInterval) {
-      window.clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    if (this.storage) {
-      await this.storage.destroy();
-      this.storage = null;
-    }
-  }
-};
-
-// src/api/api.module.ts
-var ApiClient = class {
-  /** Хранилище запросов */
-  // @ts-ignore
-  queryStorage;
-  cacheableHeaderKeys;
-  globalCacheConfig;
-  baseQueryConfig;
-  storageExternal;
-  createEndpoints;
-  /** Реестр эндпоинтов */
-  endpoints = {};
-  constructor(options) {
-    this.cacheableHeaderKeys = options.cacheableHeaderKeys;
-    this.globalCacheConfig = options.cache;
-    this.baseQueryConfig = options.baseQuery;
-    this.storageExternal = options.storage;
-    this.createEndpoints = options.endpoints;
-  }
-  async init() {
-    this.queryStorage = await new QueryStorage(this.storageExternal, this.globalCacheConfig).initialize();
-    await this.initializeEndpoints();
-    return this;
-  }
-  async initializeEndpoints() {
-    const create = (config) => config;
-    const endpointsConfig = await this.createEndpoints(create) || {};
-    for (const [endpointKey, endpointConfig] of Object.entries(endpointsConfig)) {
-      const key = endpointKey;
-      this.endpoints[key] = new EndpointClass(endpointKey, this.queryStorage, endpointConfig, this.cacheableHeaderKeys, this.globalCacheConfig, this.baseQueryConfig);
-    }
-  }
-  /**
-   * Получает все эндпоинты с улучшенной типизацией
-   * @returns Типизированный объект эндпоинтов
-   */
-  getEndpoints() {
-    return this.endpoints;
-  }
-  /**
-   * Выполняет запрос к API с типизацией и обработкой ошибок
-   * @param endpointName Имя эндпоинта (с подсказками TypeScript)
-   * @param params Параметры запроса (с типизацией)
-   * @param options Опции запроса
-   * @returns Promise с типизированным результатом запроса
-   */
-  async request(endpointName, params, options) {
-    const endpoints = this.getEndpoints();
-    const endpoint = endpoints[endpointName];
-    if (!endpoint) {
-      throw new Error(`\u042D\u043D\u0434\u043F\u043E\u0438\u043D\u0442 ${String(endpointName)} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`);
-    }
-    try {
-      const stateRequest = endpoint.request(params, options);
-      return await stateRequest.wait();
-    } catch (error) {
-      apiLogger.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u043A ${String(endpointName)}`, { error, params });
-      throw error;
-    }
-  }
-  async destroy() {
-    await Promise.all(
-      Object.values(this.endpoints).map(async (endpoint) => {
-        endpoint.destroy();
-        return Promise.resolve();
-      })
-    );
-    this.endpoints = {};
-    await this.queryStorage.destroy();
-  }
-};
-
-// 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/core/storage/modules/plugin/plugin.service.ts
-var StoragePluginModule = class {
-  constructor(parentExecutor, logger, storageName = "default") {
-    this.parentExecutor = parentExecutor;
-    this.logger = logger;
-    this.storageName = storageName;
-  }
-  plugins = /* @__PURE__ */ new Map();
-  createContext(metadata) {
-    return {
-      storageName: this.storageName,
-      timestamp: Date.now(),
-      metadata
-    };
-  }
-  async add(plugin) {
-    if (this.plugins.has(plugin.name)) {
-      this.logger?.warn(`\u041F\u043B\u0430\u0433\u0438\u043D ${plugin.name} \u0443\u0436\u0435 \u0431\u044B\u043B \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D`);
-      return;
-    }
-    try {
-      await plugin.initialize?.();
-      this.plugins.set(plugin.name, plugin);
-      this.logger?.info("\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043E\u0431\u0430\u0432\u043B\u0435\u043D", { name: plugin.name });
-    } catch (error) {
-      throw error;
-    }
-  }
-  async remove(name) {
-    const plugin = this.plugins.get(name);
-    if (plugin) {
-      await plugin.destroy?.();
-      this.plugins.delete(name);
-      this.logger?.info("\u041F\u043B\u0430\u0433\u0438\u043D \u0443\u0434\u0430\u043B\u0435\u043D", { name });
-    }
-  }
-  get(name) {
-    return this.plugins.get(name);
-  }
-  getAll() {
-    return Array.from(this.plugins.values());
-  }
-  async initialize() {
-    for (const plugin of this.plugins.values()) {
-      await plugin.initialize?.();
-    }
-  }
-  async destroy() {
-    await Promise.all(Array.from(this.plugins.values()).map((plugin) => plugin.destroy?.() ?? Promise.resolve()));
-    this.plugins.clear();
-  }
-  async executeBeforeSet(value, metadata) {
-    let result = value;
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      result = await this.parentExecutor.executeBeforeSet(result, context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onBeforeSet) {
-        try {
-          result = await plugin.onBeforeSet(result, context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeSet`, { error });
-          throw error;
-        }
-      }
-    }
-    return result;
-  }
-  async executeAfterSet(key, value, metadata) {
-    let result = value;
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      result = await this.parentExecutor.executeAfterSet(key, result, context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onAfterSet) {
-        try {
-          result = await plugin.onAfterSet(key, result, context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterSet`, { key, error });
-          throw error;
-        }
-      }
-    }
-    return result;
-  }
-  async executeBeforeGet(key, metadata) {
-    let processedKey = key;
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      processedKey = await this.parentExecutor.executeBeforeGet(processedKey, context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onBeforeGet) {
-        try {
-          processedKey = await plugin.onBeforeGet(processedKey, context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeGet`, { key, error });
-          throw error;
-        }
-      }
-    }
-    return processedKey;
-  }
-  async executeAfterGet(key, value, metadata) {
-    let result = value;
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      result = await this.parentExecutor.executeAfterGet(key, result, context);
-    }
-    console.log("executeAfterGet", key, value, metadata);
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onAfterGet) {
-        try {
-          result = await plugin.onAfterGet(key, result, context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterGet`, { key, error });
-          throw error;
-        }
-      }
-    }
-    return result;
-  }
-  async executeBeforeDelete(key, metadata) {
-    let canDelete = true;
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      canDelete = await this.parentExecutor.executeBeforeDelete(key, context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onBeforeDelete) {
-        try {
-          canDelete = await plugin.onBeforeDelete(key, context) && canDelete;
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeDelete`, { key, error });
-          throw error;
-        }
-      }
-    }
-    return canDelete;
-  }
-  async executeAfterDelete(key, metadata) {
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      await this.parentExecutor.executeAfterDelete(key, context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onAfterDelete) {
-        try {
-          await plugin.onAfterDelete(key, context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterDelete`, { key, error });
-          throw error;
-        }
-      }
-    }
-  }
-  async executeOnClear(metadata) {
-    const context = this.createContext(metadata);
-    if (this.parentExecutor) {
-      await this.parentExecutor.executeOnClear(context);
-    }
-    for (const plugin of this.plugins.values()) {
-      if (plugin.onClear) {
-        try {
-          await plugin.onClear(context);
-        } catch (error) {
-          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onClear`, { error });
-          throw error;
-        }
-      }
-    }
-  }
-};
-
-// src/core/storage/storage.interface.ts
-var StorageEvents = /* @__PURE__ */ ((StorageEvents2) => {
-  StorageEvents2["STORAGE_UPDATE"] = "storage:update";
-  StorageEvents2["STORAGE_DELETE"] = "storage:delete";
-  StorageEvents2["STORAGE_PATCH"] = "storage:patch";
-  StorageEvents2["STORAGE_SELECT"] = "storage:select";
-  StorageEvents2["STORAGE_CLEAR"] = "storage:clear";
-  StorageEvents2["STORAGE_DESTROY"] = "storage:destroy";
-  return StorageEvents2;
-})(StorageEvents || {});
-
-// src/core/storage/utils/broadcast.util.ts
-var SyncBroadcastChannel = class {
-  channel;
-  tabId;
-  messageHandlers;
-  syncHandler;
-  debug;
-  syncTimeoutMs = 1e3;
-  pendingSyncRequests;
-  constructor(channelName, options = {}) {
-    this.channel = new BroadcastChannel(channelName);
-    this.tabId = crypto.randomUUID();
-    this.messageHandlers = /* @__PURE__ */ new Set();
-    this.debug = options.debug ?? false;
-    this.pendingSyncRequests = /* @__PURE__ */ new Map();
-    this.channel.onmessage = this.handleMessage.bind(this);
-    this.channel.onmessageerror = this.handleError.bind(this);
-  }
-  log(...args) {
-    if (this.debug) {
-      console.log(`[SyncBroadcastChannel][${this.tabId}]`, ...args);
-    }
-  }
-  error(...args) {
-    console.error(`[SyncBroadcastChannel][${this.tabId}]`, ...args);
-  }
-  async handleMessage(event) {
-    const message = event.data;
-    if (message.senderId === this.tabId) {
-      return;
-    }
-    if (message.type === "SYNC_REQUEST") {
-      if (this.syncHandler) {
-        try {
-          const state = await this.syncHandler();
-          this.postMessage("SYNC_RESPONSE", state, message.senderId);
-        } catch (error) {
-          this.error("Error handling sync request:", error);
-        }
-      }
-      return;
-    }
-    if (message.type === "SYNC_RESPONSE") {
-      const request = this.pendingSyncRequests.get(this.tabId);
-      if (request) {
-        clearTimeout(request.timeout);
-        this.pendingSyncRequests.delete(this.tabId);
-        request.resolve(message.payload);
-      }
-      return;
-    }
-    for (const handler of this.messageHandlers) {
-      try {
-        await handler(message);
-      } catch (error) {
-        this.error("Error in message handler:", error);
-      }
-    }
-  }
-  handleError(event) {
-    this.error("Channel error:", event);
-  }
-  postMessage(type, payload, targetId) {
-    const message = {
-      type,
-      payload,
-      senderId: this.tabId,
-      timestamp: Date.now()
-    };
-    this.channel.postMessage(message);
-  }
-  /**
-   * Подписка на сообщения канала
-   */
-  subscribe(handler) {
-    this.messageHandlers.add(handler);
-    return () => this.messageHandlers.delete(handler);
-  }
-  /**
-   * Установка обработчика запросов на синхронизацию
-   */
-  setSyncHandler(handler) {
-    this.syncHandler = handler;
-  }
-  /**
-   * Отправка сообщения всем подписчикам
-   */
-  broadcast(type, payload) {
-    this.postMessage(type, payload);
-  }
-  /**
-   * Запрос синхронизации данных с других вкладок
-   */
-  async requestSync() {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingSyncRequests.delete(this.tabId);
-        resolve(null);
-      }, this.syncTimeoutMs);
-      this.pendingSyncRequests.set(this.tabId, { resolve, reject, timeout });
-      this.postMessage("SYNC_REQUEST", { type: "sync" });
-    });
-  }
-  /**
-   * Закрытие канала
-   */
-  close() {
-    for (const [, request] of this.pendingSyncRequests) {
-      clearTimeout(request.timeout);
-      request.reject(new Error("Channel closed"));
-    }
-    this.pendingSyncRequests.clear();
-    this.messageHandlers.clear();
-    this.syncHandler = void 0;
-    this.channel.close();
-  }
-};
-
-// src/core/storage/middlewares/broadcast.middleware.ts
-var broadcastMiddleware = (props) => {
-  const { storageName, storageType } = props;
-  const channelName = `${storageType}-${storageName}`;
-  const channel = new SyncBroadcastChannel(channelName, { debug: true });
-  return {
-    name: "sync",
-    setup: (api) => {
-      if (storageType === "memory") {
-        channel.setSyncHandler(async () => {
-          const state = await api.getState();
-          const updates = Object.entries(state).map(([key, value]) => ({
-            key,
-            value
-          }));
-          const action = {
-            type: "update",
-            key: "*",
-            value: updates,
-            metadata: {
-              batchUpdate: true,
-              timestamp: Date.now()
-            }
-          };
-          return action;
-        });
-        channel.requestSync().then(async (action) => {
-          if (action?.type === "update" && Array.isArray(action.value)) {
-            try {
-              const validUpdates = action.value.every((update) => update && typeof update === "object" && "key" in update && "value" in update);
-              if (!validUpdates) {
-                console.error("[Sync Response] Invalid updates structure:", action.value);
-                return;
-              }
-              await api.storage.doUpdate(action.value);
-              action.value.forEach(({ key, value }) => {
-                api.storage.notifySubscribers(key, value);
-              });
-              api.storage.notifySubscribers("*", {
-                type: "storage:update" /* STORAGE_UPDATE */,
-                value: action.value,
-                source: "broadcast"
-              });
-            } catch (error) {
-              console.error("[Sync Response] Error applying updates:", error);
-            }
-          }
-        });
-      }
-      return channel.subscribe(async (message) => {
-        const { type, payload } = message;
-        if (storageType === "memory") {
-          switch (type) {
-            case "set":
-              await api.storage.doSet(payload.key, payload.value);
-              api.storage.notifySubscribers(payload.key, payload.value);
-              break;
-            case "update":
-              if (Array.isArray(payload.value)) {
-                await api.storage.doUpdate(payload.value);
-                payload.value.forEach(({ key, value }) => {
-                  api.storage.notifySubscribers(key, value);
-                });
-              }
-              break;
-            case "delete":
-              await api.storage.doDelete(payload.key);
-              api.storage.notifySubscribers(payload.key, void 0);
-              break;
-            case "clear":
-              await api.storage.doClear();
-              api.storage.notifySubscribers("*", {
-                type: "storage:update" /* STORAGE_UPDATE */,
-                value: {},
-                source: "broadcast"
-              });
-              break;
-          }
-          api.storage.notifySubscribers("*", {
-            type: "storage:update" /* STORAGE_UPDATE */,
-            key: payload?.key,
-            value: payload?.value,
-            source: "broadcast"
-          });
-        }
-      });
-    },
-    reducer: (api) => (next) => async (action) => {
-      const result = await next(action);
-      if (["set", "delete", "clear", "update"].includes(action.type)) {
-        channel.broadcast(action.type, action);
-      }
-      return result;
-    },
-    cleanup: () => {
-      channel.close();
-    }
-  };
-};
-
-// src/core/storage/utils/batch.utils.ts
-var BatchProcessor = class {
-  options;
-  queues = /* @__PURE__ */ new Map();
-  timeouts = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = {
-      batchSize: options.batchSize ?? 10,
-      batchDelay: options.batchDelay ?? 300,
-      onBatch: options.onBatch ?? (async () => {
-      }),
-      getSegmentKey: options.getSegmentKey ?? (() => "default"),
-      shouldBatch: options.shouldBatch ?? (() => true),
-      mergeItems: options.mergeItems ?? ((items) => items)
-    };
-  }
-  async add(action, baseOperation) {
-    if (!this.options.shouldBatch(action)) {
-      return baseOperation();
-    }
-    return new Promise((resolve, reject) => {
-      const segment = this.options.getSegmentKey(action);
-      this.addToQueue(segment, { action, baseOperation, resolve, reject });
-    });
-  }
-  addToQueue(segment, queueItem) {
-    let queue = this.queues.get(segment);
-    if (!queue) {
-      queue = [];
-      this.queues.set(segment, queue);
-    }
-    queue.push(queueItem);
-    this.clearSegmentTimeout(segment);
-    if (queue.length >= this.options.batchSize) {
-      this.processBatch(segment);
-    } else {
-      this.setSegmentTimeout(segment);
-    }
-  }
-  async processBatch(segment) {
-    const queue = this.queues.get(segment);
-    if (!queue?.length) return;
-    this.queues.delete(segment);
-    this.clearSegmentTimeout(segment);
-    try {
-      const mergedActions = this.options.mergeItems(queue.map((item) => item.action));
-      for (let i = 0; i < mergedActions.length; i++) {
-        const result = await queue[i].baseOperation();
-        queue[i].resolve(result);
-      }
-    } catch (error) {
-      queue.forEach(({ reject }) => reject(error));
-    }
-  }
-  clearSegmentTimeout(segment) {
-    const timeout = this.timeouts.get(segment);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.timeouts.delete(segment);
-    }
-  }
-  setSegmentTimeout(segment) {
-    const timeout = setTimeout(() => {
-      this.processBatch(segment);
-    }, this.options.batchDelay);
-    this.timeouts.set(segment, timeout);
-  }
-  async flush() {
-    const segments = Array.from(this.queues.keys());
-    await Promise.all(segments.map((segment) => this.processBatch(segment)));
-  }
-  clear() {
-    this.queues.clear();
-    Array.from(this.timeouts.values()).forEach(clearTimeout);
-    this.timeouts.clear();
-  }
-  getState() {
-    const state = {};
-    this.queues.forEach((queue, segment) => {
-      state[segment] = queue.length;
-    });
-    return state;
-  }
-};
-
-// src/core/storage/middlewares/storage-batching.middleware.ts
-var batchingMiddleware = (options = {}) => {
-  const batchProcessor = new BatchProcessor({
-    batchSize: options.batchSize,
-    batchDelay: options.batchDelay,
-    shouldBatch: (action) => {
-      if (action.type === "get" || action.type === "keys") return false;
-      return true;
-    },
-    getSegmentKey: (action) => action.key || "default",
-    mergeItems: (actions) => {
-      return actions.reduce((acc, action) => {
-        if (action.type === "set") {
-          const existingIndex = acc.findIndex((existing) => existing.type === "set" && existing.key === action.key);
-          if (existingIndex !== -1) {
-            acc[existingIndex] = action;
-          } else {
-            acc.push(action);
-          }
-        } else {
-          acc.push(action);
-        }
-        return acc;
-      }, []);
-    }
-  });
-  return {
-    name: "batching",
-    setup: () => {
-    },
-    reducer: (api) => (next) => (action) => batchProcessor.add(action, () => next(action))
-  };
-};
-
-// src/core/storage/middlewares/storage-shallow-compare.middleware.ts
-var shallowCompareMiddleware = (options = {}) => {
-  const {
-    comparator = (prev, next) => {
-      if (prev === next) return true;
-      if (typeof prev !== "object" || typeof next !== "object" || prev === null || next === null) {
-        return prev === next;
-      }
-      const keysA = Object.keys(prev);
-      const keysB = Object.keys(next);
-      if (keysA.length !== keysB.length) return false;
-      return keysA.every((key) => Object.prototype.hasOwnProperty.call(next, key) && prev[key] === next[key]);
-    },
-    segments = []
-  } = options;
-  const valueCache = /* @__PURE__ */ new Map();
-  return {
-    name: "shallow-compare",
-    setup: (api) => {
-    },
-    reducer: (api) => (next) => async (action) => {
-      if (action.type !== "set" || segments.length && !segments.includes(action.metadata?.segment ?? "default")) {
-        return next(action);
-      }
-      const cacheKey = action.key;
-      const prevValue = valueCache.get(cacheKey);
-      const nextValue = action.value;
-      if (prevValue !== void 0 && comparator(prevValue, nextValue)) {
-        console.log("ShallowCompare: \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u0438\u0434\u0435\u043D\u0442\u0438\u0447\u043D\u044B, \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0430\u0435\u043C \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u044E", { key: cacheKey, value: nextValue });
-        return {
-          ...prevValue,
-          __metadata: {
-            valueNotChanged: true,
-            // Этот флаг будет проверяться в BaseStorage перед notifySubscribers
-            originalValue: prevValue
-          }
-        };
-      }
-      const result = await next(action);
-      valueCache.set(cacheKey, nextValue);
-      return result;
-    }
-  };
-};
-
-// src/core/storage/utils/middleware-module.ts
-var MiddlewareModule = class {
-  middlewares = [];
-  api;
-  initialized = false;
-  dispatchFn;
-  constructor(storage) {
-    this.api = {
-      dispatch: async (action) => this.dispatch(action),
-      getState: () => storage.getState(),
-      storage: {
-        doGet: storage.doGet.bind(storage),
-        doSet: storage.doSet.bind(storage),
-        doUpdate: storage.doUpdate.bind(storage),
-        doDelete: storage.doDelete.bind(storage),
-        doClear: storage.doClear.bind(storage),
-        doKeys: storage.doKeys.bind(storage),
-        notifySubscribers: storage.notifySubscribers.bind(storage)
-      }
-    };
-  }
-  async baseOperation(action) {
-    const { processed: _, ...metadata } = action.metadata || {};
-    const cleanAction = { ...action, metadata };
-    switch (cleanAction.type) {
-      case "get": {
-        return this.api.storage.doGet(cleanAction.key);
-      }
-      case "set": {
-        await this.api.storage.doSet(cleanAction.key, cleanAction.value);
-        return this.api.storage.doGet(cleanAction.key);
-      }
-      case "update": {
-        if (Array.isArray(cleanAction.value)) {
-          await this.api.storage.doUpdate(cleanAction.value);
-          return this.api.storage.doGet("");
-        }
-        return cleanAction.value;
-      }
-      case "delete": {
-        return this.api.storage.doDelete(cleanAction.key);
-      }
-      case "clear": {
-        return this.api.storage.doClear();
-      }
-      case "init": {
-        const currentState = await this.api.storage.doGet("");
-        if (Object.keys(currentState || {}).length > 0) {
-          return currentState;
-        }
-        if (cleanAction.value) {
-          await this.api.storage.doSet("", cleanAction.value);
-          return this.api.storage.doGet("");
-        }
-        return currentState;
-      }
-      case "keys": {
-        return this.api.storage.doKeys();
-      }
-      default: {
-        throw new Error(`Unknown action type: ${cleanAction.type}`);
-      }
-    }
-  }
-  initializeMiddlewares() {
-    if (this.initialized) return;
-    let chain = this.baseOperation.bind(this);
-    for (const middleware of [...this.middlewares].reverse()) {
-      const nextChain = chain;
-      chain = async (action) => {
-        if (action.metadata?.processed) {
-          return nextChain(action);
-        }
-        const actionWithMeta = {
-          ...action,
-          metadata: {
-            ...action.metadata,
-            processed: true,
-            timestamp: action.metadata?.timestamp || Date.now()
-          }
-        };
-        return middleware.reducer(this.api)(nextChain)(actionWithMeta);
-      };
-    }
-    this.dispatchFn = chain;
-    this.initialized = true;
-  }
-  use(middleware) {
-    if (middleware.setup) {
-      middleware.setup(this.api);
-    }
-    this.middlewares.push(middleware);
-    this.initialized = false;
-  }
-  async dispatch(action) {
-    if (!this.initialized) {
-      this.initializeMiddlewares();
-    }
-    try {
-      return this.dispatchFn(action);
-    } catch (error) {
-      console.error("Error in middleware chain:", error);
-      throw error;
-    }
-  }
-};
-
-// src/core/storage/adapters/path.utils.ts
-function parsePath(path) {
-  if (path instanceof StorageKey && path.isUnparseable()) {
-    return [path.toString()];
-  }
-  const pathStr = path.toString();
-  return pathStr.replace(/\[/g, ".").replace(/\]/g, "").split(".").filter(Boolean);
-}
-function getValueByPath(obj, path) {
-  const parts = parsePath(path);
-  return parts.reduce((curr, key) => curr === void 0 ? void 0 : curr[key], obj);
-}
-function setValueByPath(obj, path, value) {
-  if (path === "") return value;
-  const parts = parsePath(path);
-  if (path instanceof StorageKey && path.isUnparseable()) {
-    obj[path.toString()] = value;
-    return obj;
-  }
-  const lastKey = parts.pop();
-  const target = parts.reduce((curr, key) => {
-    const nextKey = parts[parts.indexOf(key) + 1];
-    const shouldBeArray = !Number.isNaN(Number(nextKey));
-    if (!(key in curr)) {
-      curr[key] = shouldBeArray ? [] : {};
-    }
-    return curr[key];
-  }, obj);
-  target[lastKey] = value;
-  return obj;
-}
-
-// src/core/storage/adapters/base-storage.service.ts
-var BaseStorage = class _BaseStorage {
-  constructor(config, pluginExecutor, eventEmitter, logger) {
-    this.config = config;
-    this.pluginExecutor = pluginExecutor;
-    this.eventEmitter = eventEmitter;
-    this.logger = logger;
-    this.name = config.name;
-    this.middlewareModule = new MiddlewareModule({
-      getState: this.getState.bind(this),
-      // Предоставляем базовые операции хранилища
-      doGet: this.doGet.bind(this),
-      doSet: this.doSet.bind(this),
-      doUpdate: this.doUpdate.bind(this),
-      doDelete: this.doDelete.bind(this),
-      doClear: this.doClear.bind(this),
-      doKeys: this.doKeys.bind(this),
-      // Предоставляем методы для работы с подписчиками
-      notifySubscribers: this.notifySubscribers.bind(this),
-      // Предоставляем плагины и эмиттер
-      pluginExecutor: this.pluginExecutor,
-      eventEmitter: this.eventEmitter,
-      logger: this.logger
-    });
-    this.initializeMiddlewares();
-  }
-  // Константа для глобальной подписки
-  static GLOBAL_SUBSCRIPTION_KEY = "*";
-  name;
-  selectorPathCache = /* @__PURE__ */ new WeakMap();
-  middlewareModule;
-  initializedMiddlewares = null;
-  subscribers = /* @__PURE__ */ new Map();
-  initializeMiddlewares() {
-    if (this.config.middlewares && !this.initializedMiddlewares) {
-      this.initializedMiddlewares = this.config.middlewares(() => this.getDefaultMiddleware());
-      this.initializedMiddlewares.forEach((middleware) => this.middlewareModule.use(middleware));
-    }
-  }
-  getDefaultMiddleware() {
-    return {
-      batching: (options = {}) => batchingMiddleware(options),
-      shallowCompare: (options = {}) => shallowCompareMiddleware(options)
-    };
-  }
-  async initializeWithMiddlewares() {
-    try {
-      const state = await this.getState();
-      const hasExistingState = Object.keys(state).length > 0;
-      if (!hasExistingState && this.config.initialState) {
-        await this.middlewareModule.dispatch({
-          type: "init",
-          value: this.config.initialState
-        });
-      }
-    } catch (error) {
-      this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430", { error });
-      throw error;
-    }
-  }
-  async get(key) {
-    try {
-      const metadata = { operation: "get", timestamp: Date.now(), key };
-      const middlewareResult = await this.middlewareModule.dispatch({
-        type: "get",
-        key,
-        metadata
-      });
-      const finalResult = await this.pluginExecutor?.executeAfterGet(key, middlewareResult, metadata) ?? middlewareResult;
-      await this.emitEvent({
-        type: "storage:select" /* STORAGE_SELECT */,
-        payload: { key, value: finalResult }
-      });
-      return finalResult;
-    } catch (error) {
-      this.logger?.error("Error getting value", { key, error });
-      throw error;
-    }
-  }
-  async set(key, value) {
-    try {
-      const metadata = { operation: "set", timestamp: Date.now(), key };
-      const processedValue = await this.pluginExecutor?.executeBeforeSet(value, metadata) ?? value;
-      const middlewareResult = await this.middlewareModule.dispatch({
-        type: "set",
-        key,
-        value: processedValue,
-        metadata
-      });
-      const valueNotChanged = middlewareResult?.__metadata?.valueNotChanged === true;
-      let finalResult;
-      if (valueNotChanged && middlewareResult?.__metadata?.originalValue !== void 0) {
-        finalResult = middlewareResult.__metadata.originalValue;
-      } else {
-        finalResult = await this.pluginExecutor?.executeAfterSet(key, middlewareResult, metadata) ?? middlewareResult;
-      }
-      if (!valueNotChanged) {
-        const keyStr = key.toString();
-        const changedPaths = [keyStr];
-        this.notifySubscribers(key, finalResult);
-        this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
-          type: "storage:update" /* STORAGE_UPDATE */,
-          key,
-          value: finalResult,
-          changedPaths
-        });
-        await this.emitEvent({
-          type: "storage:update" /* STORAGE_UPDATE */,
-          payload: {
-            key,
-            value: finalResult,
-            changedPaths
-          }
-        });
-      }
-    } catch (error) {
-      this.logger?.error("Error setting value", { key, error });
-      throw error;
-    }
-  }
-  async update(updater) {
-    try {
-      const metadata = { operation: "update", timestamp: Date.now() };
-      const currentState = await this.getState();
-      const newState = structuredClone(currentState);
-      updater(newState);
-      const changedPaths = this.findChangedPaths(currentState, newState);
-      if (changedPaths.size === 0) {
-        if (this.logger?.debug) {
-          this.logger.debug("No changes detected in update");
-        }
-        return;
-      }
-      if (this.logger?.debug) {
-        this.logger.debug("Changed paths:", { paths: Array.from(changedPaths) });
-      }
-      const changedTopLevelKeys = /* @__PURE__ */ new Set();
-      for (const path of changedPaths) {
-        const topLevelKey = path.split(".")[0];
-        changedTopLevelKeys.add(topLevelKey);
-      }
-      const updates = await Promise.all(
-        Array.from(changedTopLevelKeys).map(async (key) => {
-          const keyMetadata = { ...metadata, key };
-          const processedValue = await this.pluginExecutor?.executeBeforeSet(newState[key], keyMetadata) ?? newState[key];
-          return { key, value: processedValue };
-        })
-      );
-      const result = await this.middlewareModule.dispatch({
-        type: "update",
-        value: updates,
-        metadata: {
-          ...metadata,
-          batchUpdate: true,
-          changedPaths: Array.from(changedPaths)
-        }
-      });
-      let updatedValues = {};
-      if (Array.isArray(result)) {
-        result.forEach((update) => {
-          if (update && typeof update === "object" && "key" in update && "value" in update) {
-            updatedValues[update.key] = update.value;
-          }
-        });
-      } else if (result && typeof result === "object") {
-        updatedValues = { ...result };
-      }
-      const actuallyChangedKeys = Object.keys(updatedValues).filter((key) => !this.isEqual(currentState[key], updatedValues[key]));
-      if (actuallyChangedKeys.length === 0) {
-        if (this.logger?.debug) {
-          this.logger.debug("No actual changes after middleware processing");
-        }
-        return;
-      }
-      const finalUpdates = {};
-      actuallyChangedKeys.forEach((key) => {
-        finalUpdates[key] = updatedValues[key];
-      });
-      if (this.logger?.debug) {
-        this.logger.debug("Notifying subscribers about changes:", { keys: actuallyChangedKeys });
-      }
-      this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
-        type: "storage:update" /* STORAGE_UPDATE */,
-        key: actuallyChangedKeys,
-        value: finalUpdates,
-        changedPaths: Array.from(changedPaths)
-        // Добавляем информацию о всех изменившихся путях
-      });
-      for (const path of changedPaths) {
-        try {
-          const topLevelKey = path.split(".")[0];
-          if (topLevelKey in finalUpdates) {
-            let value;
-            if (path === topLevelKey) {
-              value = finalUpdates[topLevelKey];
-            } else {
-              const restPath = path.substring(topLevelKey.length + 1);
-              value = getValueByPath(finalUpdates[topLevelKey], restPath);
-            }
-            if (value !== void 0) {
-              this.notifySubscribers(path, value);
-            }
-          }
-        } catch (error) {
-          this.logger?.error("Error notifying path subscribers", { path, error });
-        }
-      }
-      await this.emitEvent({
-        type: "storage:update" /* STORAGE_UPDATE */,
-        payload: {
-          state: finalUpdates,
-          key: actuallyChangedKeys,
-          changedPaths: Array.from(changedPaths)
-        }
-      });
-    } catch (error) {
-      this.logger?.error("Error updating state", { error });
-      throw error;
-    }
-  }
-  async delete(key) {
-    try {
-      const metadata = { operation: "delete", timestamp: Date.now(), key };
-      if (await this.pluginExecutor?.executeBeforeDelete(key, metadata)) {
-        const middlewareResult = await this.middlewareModule.dispatch({
-          type: "delete",
-          key,
-          metadata
-        });
-        await this.pluginExecutor?.executeAfterDelete(key, metadata);
-        const keyStr = key.toString();
-        const changedPaths = [keyStr];
-        this.notifySubscribers(key, void 0);
-        this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
-          type: "storage:update" /* STORAGE_UPDATE */,
-          key,
-          value: void 0,
-          result: middlewareResult,
-          changedPaths
-        });
-        await this.emitEvent({
-          type: "storage:update" /* STORAGE_UPDATE */,
-          payload: {
-            key,
-            value: void 0,
-            result: middlewareResult,
-            changedPaths
-          }
-        });
-      }
-    } catch (error) {
-      this.logger?.error("Error deleting value", { key, error });
-      throw error;
-    }
-  }
-  async clear() {
-    try {
-      this.pluginExecutor?.executeOnClear();
-      await this.middlewareModule.dispatch({
-        type: "clear"
-      });
-    } catch (error) {
-      this.logger?.error("Error clearing storage", { error });
-      throw error;
-    }
-  }
-  async keys() {
-    try {
-      return await this.middlewareModule.dispatch({
-        type: "keys"
-      });
-    } catch (error) {
-      this.logger?.error("Error getting keys", { error });
-      throw error;
-    }
-  }
-  async has(key) {
-    try {
-      return await this.doHas(key);
-    } catch (error) {
-      this.logger?.error("Error checking value existence", { key, error });
-      throw error;
-    }
-  }
-  async getState() {
-    try {
-      const value = await this.doGet("");
-      return value || {};
-    } catch (error) {
-      this.logger?.error("Error getting state", { error });
-      throw error;
-    }
-  }
-  // Вспомогательный метод для подписки на все изменения
-  subscribeToAll(callback) {
-    if (!this.subscribers.has(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY)) {
-      this.subscribers.set(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, /* @__PURE__ */ new Set());
-    }
-    this.subscribers.get(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY).add(callback);
-    return () => {
-      const subscribers = this.subscribers.get(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY);
-      if (subscribers) {
-        subscribers.delete(callback);
-        if (subscribers.size === 0) {
-          this.subscribers.delete(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY);
-        }
-      }
-    };
-  }
-  subscribe(keyOrSelector, callback) {
-    if (typeof keyOrSelector === "string") {
-      return this.subscribeByKey(keyOrSelector, callback);
-    }
-    return this.subscribeBySelector(keyOrSelector, callback);
-  }
-  async destroy() {
-    try {
-      await this.clear();
-      await this.doDestroy();
-      if (this.initializedMiddlewares) {
-        await Promise.all(
-          this.initializedMiddlewares.map(async (middleware) => {
-            if ("cleanup" in middleware) {
-              await middleware.cleanup?.();
-            }
-          })
-        );
-        this.initializedMiddlewares = null;
-      }
-      await this.emitEvent({
-        type: "storage:destroy" /* STORAGE_DESTROY */
-      });
-    } catch (error) {
-      this.logger?.error("Error destroying storage", { error });
-      throw error;
-    }
-  }
-  // Вспомогательные методы
-  subscribeByKey(key, callback) {
-    if (!this.subscribers.has(key)) {
-      this.subscribers.set(key, /* @__PURE__ */ new Set());
-    }
-    let initialValueSent = false;
-    this.subscribers.get(key).add(callback);
-    this.get(key).then((value) => {
-      try {
-        if (!initialValueSent) {
-          initialValueSent = true;
-          callback(value);
-        }
-      } catch (error) {
-        this.logger?.error("Error in initial callback", { key, error });
-      }
-    });
-    return () => {
-      const subscribers = this.subscribers.get(key);
-      if (subscribers) {
-        subscribers.delete(callback);
-        if (subscribers.size === 0) {
-          this.subscribers.delete(key);
-        }
-      }
-    };
-  }
-  createDummyState() {
-    const handler = {
-      get: (target, prop) => {
-        target[prop] = target[prop] || new Proxy({}, handler);
-        return target[prop];
-      }
-    };
-    return new Proxy({}, handler);
-  }
-  isEqual(a, b) {
-    if (a === b) return true;
-    if (a == null || b == null) return a === b;
-    const typeA = typeof a;
-    const typeB = typeof b;
-    if (typeA !== typeB) return false;
-    if (typeA !== "object") return a === b;
-    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 (!this.isEqual(a[i], b[i])) return false;
-      }
-      return true;
-    }
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && this.isEqual(a[key], b[key]));
-  }
-  /**
-   * Возвращает полный путь, а не только корневой ключ
-   */
-  extractPath(selector, dummyState) {
-    if (this.selectorPathCache.has(selector)) {
-      return this.selectorPathCache.get(selector);
-    }
-    const accessedPaths = [];
-    const createProxyHandler = (path = "") => ({
-      get: (target, prop) => {
-        if (typeof prop === "symbol") {
-          return Reflect.get(target, prop);
-        }
-        const currentPath = path ? `${path}.${prop}` : prop;
-        accessedPaths.push(currentPath);
-        return new Proxy({}, createProxyHandler(currentPath));
-      },
-      // Обработка опциональной цепочки (?.)
-      has: (target, prop) => {
-        return true;
-      },
-      // Поддержка для Array.prototype.map и других операций над массивами
-      ownKeys: () => [],
-      getOwnPropertyDescriptor: () => ({
-        configurable: true,
-        enumerable: true
-      }),
-      apply: (target, thisArg, args) => {
-        return new Proxy(() => {
-        }, createProxyHandler(path));
-      }
-    });
-    try {
-      selector(new Proxy(dummyState, createProxyHandler()));
-    } catch (error) {
-    }
-    if (accessedPaths.length === 0) return "";
-    accessedPaths.sort((a, b) => b.length - a.length);
-    this.selectorPathCache.set(selector, accessedPaths[0]);
-    return accessedPaths[0];
-  }
-  notifySubscribers(key, value) {
-    const keyStr = key.toString();
-    const exactSubscribers = this.subscribers.get(keyStr);
-    if (exactSubscribers?.size) {
-      const subscribersCopy = new Set(exactSubscribers);
-      subscribersCopy.forEach((callback) => {
-        try {
-          callback(value);
-        } catch (error) {
-          this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0435 \u043D\u0430 \u043A\u043E\u043B\u0431\u044D\u043A", { key: keyStr, error });
-        }
-      });
-    }
-  }
-  /**
-   * Метод для определения изменившихся путей между двумя объектами
-   */
-  findChangedPaths(oldObj, newObj, prefix = "", changedPaths = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new WeakMap()) {
-    if (oldObj === newObj) return changedPaths;
-    if (typeof oldObj !== "object" || typeof newObj !== "object" || oldObj === null || newObj === null) {
-      if (oldObj !== newObj) {
-        changedPaths.add(prefix || "");
-      }
-      return changedPaths;
-    }
-    if (visited.has(oldObj)) return changedPaths;
-    visited.set(oldObj, true);
-    const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldObj || {}), ...Object.keys(newObj || {})]);
-    for (const key of allKeys) {
-      const oldValue = oldObj[key];
-      const newValue = newObj[key];
-      if (oldValue === newValue) continue;
-      const path = prefix ? `${prefix}.${key}` : key;
-      if (oldValue && newValue && typeof oldValue === "object" && typeof newValue === "object" && !Array.isArray(oldValue) && !Array.isArray(newValue)) {
-        this.findChangedPaths(oldValue, newValue, path, changedPaths, visited);
-      } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
-        if (!this.isEqual(oldValue, newValue)) {
-          changedPaths.add(path);
-        }
-      } else if (!this.isEqual(oldValue, newValue)) {
-        changedPaths.add(path);
-      }
-    }
-    return changedPaths;
-  }
-  subscribeBySelector(pathSelector, callback) {
-    const dummyState = this.createDummyState();
-    const fullPath = this.extractPath(pathSelector, dummyState);
-    if (this.logger?.debug) {
-      this.logger.debug("Subscribing to path:", { path: fullPath });
-    }
-    const wrappedCallback = async (value) => {
-      try {
-        if (value === void 0 || value === null) {
-          const currentState2 = await this.getState();
-          const selectedValue2 = pathSelector(currentState2);
-          callback(selectedValue2);
-          return;
-        }
-        if (typeof value !== "object" || value === null) {
-          callback(value);
-          return;
-        }
-        const currentState = await this.getState();
-        const selectedValue = pathSelector(currentState);
-        callback(selectedValue);
-      } catch (error) {
-        this.logger?.error("Error in selector callback", { path: fullPath, error });
-        callback(value);
-      }
-    };
-    if (!fullPath) {
-      return this.subscribeToAll(() => {
-        this.getState().then((state) => {
-          callback(pathSelector(state));
-        });
-      });
-    }
-    return this.subscribeByKey(fullPath, wrappedCallback);
-  }
-  async emitEvent(event) {
-    try {
-      await this.eventEmitter?.emit({
-        ...event,
-        metadata: {
-          ...event.metadata || {},
-          timestamp: Date.now(),
-          storageName: this.name
-        }
-      });
-    } catch (error) {
-      this.logger?.error("Error emitting event", { event, error });
-    }
-  }
-};
-
-// src/core/storage/adapters/indexed-DB.service.ts
-var IndexedDBManager = class _IndexedDBManager {
-  constructor(dbName, dbVersion, logger) {
-    this.dbName = dbName;
-    this.logger = logger;
-    this.dbVersion = dbVersion;
-  }
-  static instances = /* @__PURE__ */ new Map();
-  db = null;
-  initPromise = null;
-  storeNames = /* @__PURE__ */ new Set();
-  dbVersion;
-  static getInstance(dbName, dbVersion = 1, logger) {
-    if (!_IndexedDBManager.instances.has(dbName)) {
-      _IndexedDBManager.instances.set(dbName, new _IndexedDBManager(dbName, dbVersion, logger));
-    }
-    const instance = _IndexedDBManager.instances.get(dbName);
-    if (dbVersion > instance.dbVersion) {
-      instance.dbVersion = dbVersion;
-    }
-    return instance;
-  }
-  async initialize() {
-    if (this.db) {
-      return this.db;
-    }
-    if (!this.initPromise) {
-      this.initPromise = this.openDatabase();
-    }
-    return this.initPromise;
-  }
-  async ensureStoreExists(storeName) {
-    await this.initialize();
-    if (this.db.objectStoreNames.contains(storeName)) {
-      this.storeNames.add(storeName);
-      return this.db;
-    }
-    this.logger?.debug(`Store "${storeName}" not found, upgrading database`, {
-      dbName: this.dbName,
-      currentStores: Array.from(this.db.objectStoreNames)
-    });
-    this.db.close();
-    this.db = null;
-    this.dbVersion++;
-    this.initPromise = this.openDatabase([storeName]);
-    const newDb = await this.initPromise;
-    this.storeNames.add(storeName);
-    return newDb;
-  }
-  async openDatabase(newStores = []) {
-    return new Promise((resolve, reject) => {
-      this.logger?.debug(`Opening database "${this.dbName}" with version ${this.dbVersion}`);
-      const request = indexedDB.open(this.dbName, this.dbVersion);
-      request.onerror = () => {
-        this.logger?.error(`Failed to open database "${this.dbName}"`, { error: request.error });
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        this.db = request.result;
-        for (let i = 0; i < this.db.objectStoreNames.length; i++) {
-          this.storeNames.add(this.db.objectStoreNames[i]);
-        }
-        this.logger?.debug(`Database "${this.dbName}" opened successfully`, {
-          version: this.db.version,
-          stores: Array.from(this.db.objectStoreNames)
-        });
-        resolve(this.db);
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        this.logger?.debug(`Upgrading database "${this.dbName}" to version ${this.dbVersion}`);
-        for (const storeName of newStores) {
-          if (!db.objectStoreNames.contains(storeName)) {
-            this.logger?.debug(`Creating store "${storeName}"`);
-            db.createObjectStore(storeName);
-          }
-        }
-      };
-    });
-  }
-  closeDatabase() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      this.initPromise = null;
-    }
-  }
-  async deleteDatabase() {
-    this.closeDatabase();
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.deleteDatabase(this.dbName);
-      request.onsuccess = () => {
-        this.logger?.debug(`Database "${this.dbName}" deleted successfully`);
-        _IndexedDBManager.instances.delete(this.dbName);
-        this.storeNames.clear();
-        resolve();
-      };
-      request.onerror = () => {
-        this.logger?.error(`Failed to delete database "${this.dbName}"`, { error: request.error });
-        reject(request.error);
-      };
-    });
-  }
-  async ensureStoresExist(storeNames) {
-    await this.initialize();
-    const missingStores = storeNames.filter((name) => !this.db.objectStoreNames.contains(name));
-    if (missingStores.length === 0) {
-      return this.db;
-    }
-    this.logger?.debug(`\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0445 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449: ${missingStores.join(", ")}`, {
-      dbName: this.dbName,
-      currentStores: Array.from(this.db.objectStoreNames)
-    });
-    this.db.close();
-    this.db = null;
-    this.dbVersion++;
-    this.initPromise = this.openDatabase(missingStores);
-    return this.initPromise;
-  }
-  // Метод для получения текущей версии
-  getCurrentVersion() {
-    return this.dbVersion;
-  }
-};
-var DBVersionManager = class {
-  constructor(dbName, initialVersion = 1, logger) {
-    this.dbName = dbName;
-    this.logger = logger;
-    this.version = initialVersion;
-  }
-  db = null;
-  version;
-  /**
-   * Получает текущую версию базы данных
-   */
-  getCurrentVersion() {
-    return this.version;
-  }
-  /**
-   * Открывает базу данных с заданной версией
-   */
-  openDatabase(version, newStores = []) {
-    return new Promise((resolve, reject) => {
-      this.logger?.debug(`\u041E\u0442\u043A\u0440\u044B\u0442\u0438\u0435 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0441 \u0432\u0435\u0440\u0441\u0438\u0435\u0439 ${version}`);
-      const request = indexedDB.open(this.dbName, version);
-      request.onerror = () => {
-        this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u0442\u043A\u0440\u044B\u0442\u0438\u0438 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}"`, { error: request.error });
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        this.db = request.result;
-        this.version = this.db.version;
-        this.logger?.debug(`\u0411\u0430\u0437\u0430 \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0443\u0441\u043F\u0435\u0448\u043D\u043E \u043E\u0442\u043A\u0440\u044B\u0442\u0430`, {
-          version: this.db.version,
-          stores: Array.from(this.db.objectStoreNames)
-        });
-        resolve(this.db);
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        this.logger?.debug(`\u041E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0434\u043E \u0432\u0435\u0440\u0441\u0438\u0438 ${version}`);
-        for (const storeName of newStores) {
-          if (!db.objectStoreNames.contains(storeName)) {
-            this.logger?.debug(`\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 "${storeName}"`);
-            db.createObjectStore(storeName);
-          }
-        }
-      };
-    });
-  }
-  /**
-   * Убеждается, что все указанные хранилища существуют в базе данных
-   */
-  async ensureStoresExist(storeNames) {
-    if (!this.db) {
-      this.db = await this.openDatabase(this.version);
-    }
-    const missingStores = storeNames.filter((name) => !this.db.objectStoreNames.contains(name));
-    if (missingStores.length === 0) {
-      return this.db;
-    }
-    this.logger?.debug(`\u041D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u0441\u043E\u0437\u0434\u0430\u0442\u044C \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430: ${missingStores.join(", ")}`, {
-      dbName: this.dbName,
-      currentVersion: this.version
-    });
-    this.db.close();
-    this.db = null;
-    this.version++;
-    this.db = await this.openDatabase(this.version, missingStores);
-    return this.db;
-  }
-  /**
-   * Закрывает соединение с базой данных
-   */
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-};
-var IndexedDBStorage = class _IndexedDBStorage extends BaseStorage {
-  DB_NAME;
-  STORE_NAME;
-  DB_VERSION;
-  dbManager;
-  constructor(config, pluginExecutor, eventEmitter, logger) {
-    super(config, pluginExecutor, eventEmitter, logger);
-    const options = config.options;
-    this.DB_NAME = options.dbName || "app_storage";
-    this.STORE_NAME = config.name;
-    this.DB_VERSION = options.dbVersion || 1;
-    this.dbManager = IndexedDBManager.getInstance(this.DB_NAME, this.DB_VERSION, logger);
-  }
-  async initialize() {
-    try {
-      this.logger?.debug(`Initializing IndexedDB storage "${this.STORE_NAME}"`);
-      await this.dbManager.ensureStoreExists(this.STORE_NAME);
-      try {
-        const db = await this.dbManager.initialize();
-        if (!db.objectStoreNames.contains(this.STORE_NAME)) {
-          throw new Error(`Store "${this.STORE_NAME}" not found after initialization`);
-        }
-      } catch (error) {
-        this.logger?.error(`Error verifying store "${this.STORE_NAME}" exists:`, { error });
-        throw error;
-      }
-      this.initializeMiddlewares();
-      try {
-        await this.initializeWithMiddlewares();
-        this.logger?.debug(`IndexedDB storage "${this.STORE_NAME}" initialized successfully`);
-      } catch (error) {
-        this.logger?.error(`Failed to initialize middleware for store "${this.STORE_NAME}"`, { error });
-      }
-      return this;
-    } catch (error) {
-      this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 IndexedDB "${this.name}"`, { error });
-      throw error;
-    }
-  }
-  static async getCurrentDBVersion(dbName) {
-    return new Promise((resolve) => {
-      try {
-        const request = indexedDB.open(dbName);
-        request.onsuccess = () => {
-          const version = request.result.version;
-          request.result.close();
-          resolve(version);
-        };
-        request.onerror = () => {
-          console.warn(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0438 \u0432\u0435\u0440\u0441\u0438\u0438 \u0411\u0414 ${dbName}`, request.error);
-          resolve(0);
-        };
-      } catch (error) {
-        console.warn(`\u0418\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u043F\u0440\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0438 \u0432\u0435\u0440\u0441\u0438\u0438 \u0411\u0414 ${dbName}`, error);
-        resolve(0);
-      }
-    });
-  }
-  static async createStorages(dbName, configs, logger) {
-    const currentVersion = await this.getCurrentDBVersion(dbName);
-    const initialVersion = currentVersion || 1;
-    const dbManager = new DBVersionManager(dbName, initialVersion, logger);
-    const storeNames = Object.values(configs).map((config) => config.name);
-    await dbManager.ensureStoresExist(storeNames);
-    const result = {};
-    for (const [key, config] of Object.entries(configs)) {
-      const storage = new _IndexedDBStorage(
-        {
-          ...config,
-          options: {
-            dbName,
-            dbVersion: dbManager.getCurrentVersion()
-          }
-        },
-        config.pluginExecutor,
-        config.eventEmitter,
-        logger
-      );
-      result[key] = await storage.initialize();
-    }
-    return result;
-  }
-  async getTransaction(mode = "readonly") {
-    try {
-      const db = await this.dbManager.ensureStoreExists(this.STORE_NAME);
-      if (!db.objectStoreNames.contains(this.STORE_NAME)) {
-        this.logger?.warn(`Object store "${this.STORE_NAME}" not found, attempting to repair`);
-        db.close();
-        this.dbManager.closeDatabase();
-        const newDb = await this.dbManager.ensureStoreExists(this.STORE_NAME);
-        if (!newDb.objectStoreNames.contains(this.STORE_NAME)) {
-          throw new Error(`Object store "${this.STORE_NAME}" still doesn't exist after repair attempt`);
-        }
-        return newDb.transaction(this.STORE_NAME, mode);
-      }
-      return db.transaction(this.STORE_NAME, mode);
-    } catch (error) {
-      this.logger?.error(`Failed to create transaction for store "${this.STORE_NAME}"`, { error });
-      throw error;
-    }
-  }
-  async getObjectStore(mode = "readonly") {
-    const transaction = await this.getTransaction(mode);
-    return transaction.objectStore(this.STORE_NAME);
-  }
-  async doGet(key) {
-    const store = await this.getObjectStore();
-    if (key === "") {
-      return new Promise((resolve, reject) => {
-        const request = store.getAll();
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-          const allValues = request.result;
-          const allKeys = store.getAllKeys();
-          allKeys.onsuccess = () => {
-            const state = allKeys.result.reduce(
-              (acc, k, index) => {
-                if (k !== "root") {
-                  acc[k] = allValues[index];
-                }
-                return acc;
-              },
-              {}
-            );
-            resolve(state);
-          };
-          allKeys.onerror = () => reject(allKeys.error);
-        };
-      });
-    }
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      return new Promise((resolve, reject) => {
-        const request = store.get(key.valueOf());
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve(request.result);
-      });
-    }
-    const parts = parsePath(key);
-    if (parts.length > 1) {
-      const rootKey = parts[0];
-      return new Promise((resolve, reject) => {
-        const request = store.get(rootKey);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-          const rootValue = request.result;
-          if (!rootValue) {
-            resolve(void 0);
-            return;
-          }
-          const value = getValueByPath(rootValue, parts.slice(1).join("."));
-          resolve(value);
-        };
-      });
-    }
-    return new Promise((resolve, reject) => {
-      const request = store.get(parts[0]);
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(request.result);
-    });
-  }
-  async doSet(key, value) {
-    if (key === "") {
-      const store2 = await this.getObjectStore("readwrite");
-      return new Promise((resolve, reject) => {
-        const tx = store2.transaction;
-        tx.oncomplete = () => {
-          resolve();
-        };
-        tx.onerror = () => {
-          reject(tx.error);
-        };
-        const clearRequest = store2.clear();
-        clearRequest.onsuccess = () => {
-          const entries = Object.entries(value);
-          for (const [entryKey, entryValue] of entries) {
-            store2.put(entryValue, entryKey);
-          }
-        };
-        clearRequest.onerror = () => {
-          reject(clearRequest.error);
-        };
-      });
-    }
-    const store = await this.getObjectStore("readwrite");
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      await this.putValueInStore(store, key.valueOf(), value);
-      return;
-    }
-    const parts = parsePath(key);
-    if (parts.length > 1) {
-      const rootKey = parts[0];
-      return new Promise((resolve, reject) => {
-        const request = store.get(rootKey);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-          const rootValue = request.result || {};
-          const updatedValue = setValueByPath(rootValue, parts.slice(1).join("."), value);
-          const putRequest = store.put(updatedValue, rootKey);
-          putRequest.onerror = () => reject(putRequest.error);
-          putRequest.onsuccess = () => resolve();
-        };
-      });
-    }
-    await this.putValueInStore(store, parts[0], value);
-  }
-  async putValueInStore(store, key, value) {
-    return new Promise((resolve, reject) => {
-      const request = store.put(value, key.valueOf());
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve();
-    });
-  }
-  async doUpdate(updates) {
-    const updatesByRoot = /* @__PURE__ */ new Map();
-    const rawUpdates = [];
-    for (const { key, value } of updates) {
-      if (key instanceof StorageKey && key.isUnparseable()) {
-        rawUpdates.push({ key: key.valueOf(), value });
-        continue;
-      }
-      const parts = parsePath(key);
-      const rootKey = parts[0];
-      const path = parts.slice(1);
-      if (!updatesByRoot.has(rootKey)) {
-        updatesByRoot.set(rootKey, []);
-      }
-      updatesByRoot.get(rootKey).push({ path, value });
-    }
-    try {
-      for (const { key, value } of rawUpdates) {
-        const store = await this.getObjectStore("readwrite");
-        await this.putValueInStore(store, key, value);
-      }
-      for (const [rootKey, pathUpdates] of updatesByRoot) {
-        const rootValue = await this.doGet(rootKey) || {};
-        let updatedValue = { ...rootValue };
-        for (const { path, value } of pathUpdates) {
-          if (path.length === 0) {
-            updatedValue = value;
-          } else {
-            updatedValue = setValueByPath(updatedValue, path.join("."), value);
-          }
-        }
-        const store = await this.getObjectStore("readwrite");
-        await this.putValueInStore(store, rootKey, updatedValue);
-      }
-    } catch (error) {
-      this.logger?.error("Error during update:", { error });
-      throw error;
-    }
-  }
-  async doDelete(key) {
-    const store = await this.getObjectStore("readwrite");
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      return new Promise((resolve, reject) => {
-        const request = store.delete(key.valueOf());
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve(true);
-      });
-    }
-    const parts = parsePath(key);
-    if (parts.length === 1) {
-      return new Promise((resolve, reject) => {
-        const request = store.delete(parts[0]);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve(true);
-      });
-    }
-    const rootKey = parts[0];
-    return new Promise((resolve, reject) => {
-      const getRequest = store.get(rootKey);
-      getRequest.onerror = () => reject(getRequest.error);
-      getRequest.onsuccess = () => {
-        const rootValue = getRequest.result;
-        if (!rootValue) {
-          resolve(false);
-          return;
-        }
-        const parent = getValueByPath(rootValue, parts.slice(0, -1).join("."));
-        const lastKey = parts[parts.length - 1];
-        if (!parent || !(lastKey in parent)) {
-          resolve(false);
-          return;
-        }
-        if (Array.isArray(parent)) {
-          const index = parseInt(lastKey, 10);
-          if (!isNaN(index)) {
-            parent.splice(index, 1);
-          } else {
-            delete parent[lastKey];
-          }
-        } else {
-          delete parent[lastKey];
-        }
-        const putRequest = store.put(rootValue, rootKey);
-        putRequest.onerror = () => reject(putRequest.error);
-        putRequest.onsuccess = () => resolve(true);
-      };
-    });
-  }
-  async doClear() {
-    const store = await this.getObjectStore("readwrite");
-    return new Promise((resolve, reject) => {
-      const request = store.clear();
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-  async doKeys() {
-    const store = await this.getObjectStore();
-    const request = store.getAllKeys();
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => {
-        resolve(request.result);
-      };
-      request.onerror = () => reject(request.error);
-    });
-  }
-  async doHas(key) {
-    const value = await this.doGet(key);
-    return value !== void 0;
-  }
-  async doDestroy() {
-    try {
-      await this.doClear();
-    } catch (error) {
-      this.logger?.error(`Error destroying store "${this.STORE_NAME}"`, { error });
-      throw error;
-    }
-  }
-};
-
-// src/core/storage/adapters/local-storage.service.ts
-var LocalStorage = class extends BaseStorage {
-  constructor(config, pluginExecutor, eventEmitter, logger) {
-    super(config, pluginExecutor, eventEmitter, logger);
-  }
-  async initialize() {
-    try {
-      await this.initializeWithMiddlewares();
-      return this;
-    } catch (error) {
-      this.logger?.error("Error initializing LocalStorage", { error });
-      throw error;
-    }
-  }
-  async doGet(key) {
-    const storageData = localStorage.getItem(this.name);
-    if (!storageData) return void 0;
-    const state = JSON.parse(storageData);
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      return state[key.valueOf()];
-    }
-    return getValueByPath(state, key);
-  }
-  async doSet(key, value) {
-    const storageData = localStorage.getItem(this.name);
-    const state = storageData ? JSON.parse(storageData) : {};
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      state[key.valueOf()] = value;
-      localStorage.setItem(this.name, JSON.stringify(state));
-      return;
-    }
-    const newState = setValueByPath({ ...state }, key, value);
-    localStorage.setItem(this.name, JSON.stringify(newState));
-  }
-  async doDelete(key) {
-    const storageData = localStorage.getItem(this.name);
-    if (!storageData) return false;
-    const state = JSON.parse(storageData);
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      const rawKey = key.valueOf();
-      if (!(rawKey in state)) return false;
-      delete state[rawKey];
-      localStorage.setItem(this.name, JSON.stringify(state));
-      return true;
-    }
-    const pathParts = parsePath(key);
-    const parentPath = pathParts.slice(0, -1).join(".");
-    const lastKey = pathParts[pathParts.length - 1];
-    const parent = parentPath ? getValueByPath(state, parentPath) : state;
-    if (!parent || !(lastKey in parent)) return false;
-    delete parent[lastKey];
-    localStorage.setItem(this.name, JSON.stringify(state));
-    return true;
-  }
-  async doUpdate(updates) {
-    const storageData = localStorage.getItem(this.name);
-    const state = storageData ? JSON.parse(storageData) : {};
-    for (const { key, value } of updates) {
-      if (key instanceof StorageKey && key.isUnparseable()) {
-        state[key.valueOf()] = value;
-      } else {
-        setValueByPath(state, key, value);
-      }
-    }
-    localStorage.setItem(this.name, JSON.stringify(state));
-  }
-  async doClear() {
-    localStorage.removeItem(this.name);
-  }
-  async doKeys() {
-    const storageData = localStorage.getItem(this.name);
-    if (!storageData) return [];
-    const state = JSON.parse(storageData);
-    return this.getAllKeys(state);
-  }
-  async doHas(key) {
-    const value = await this.doGet(key);
-    return value !== void 0;
-  }
-  getAllKeys(obj) {
-    return Object.keys(obj);
-  }
-  async doDestroy() {
-    await this.doClear();
-  }
-};
-
-// src/core/storage/adapters/memory-storage.service.ts
-var MemoryStorage = class extends BaseStorage {
-  storage = /* @__PURE__ */ new Map();
-  constructor(config, pluginExecutor, eventEmitter, logger) {
-    super(config, pluginExecutor, eventEmitter, logger);
-  }
-  async initialize() {
-    try {
-      this.initializeMiddlewares();
-      await this.initializeWithMiddlewares();
-      return this;
-    } catch (error) {
-      this.logger?.error("Error initializing MemoryStorage", { error });
-      throw error;
-    }
-  }
-  async doGet(key) {
-    const state = this.storage.get(this.name);
-    if (!state) return void 0;
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      return state[key.valueOf()];
-    }
-    return getValueByPath(state, key);
-  }
-  async doSet(key, value) {
-    const state = this.storage.get(this.name) || {};
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      state[key.valueOf()] = value;
-      this.storage.set(this.name, state);
-      return;
-    }
-    const newState = setValueByPath({ ...state }, key, value);
-    this.storage.set(this.name, newState);
-  }
-  async doDelete(key) {
-    const state = this.storage.get(this.name);
-    if (!state) return false;
-    if (key instanceof StorageKey && key.isUnparseable()) {
-      const rawKey = key.valueOf();
-      if (!(rawKey in state)) return false;
-      delete state[rawKey];
-      this.storage.set(this.name, state);
-      return true;
-    }
-    const pathParts = parsePath(key);
-    const parentPath = pathParts.slice(0, -1).join(".");
-    const lastKey = pathParts[pathParts.length - 1];
-    const parent = parentPath ? getValueByPath(state, parentPath) : state;
-    if (!parent || !(lastKey in parent)) return false;
-    delete parent[lastKey];
-    this.storage.set(this.name, state);
-    return true;
-  }
-  async doUpdate(updates) {
-    const currentState = this.storage.get(this.name) || {};
-    const newState = { ...currentState };
-    for (const { key, value } of updates) {
-      if (key instanceof StorageKey && key.isUnparseable()) {
-        newState[key.valueOf()] = value;
-      } else {
-        setValueByPath(newState, key, value);
-      }
-    }
-    this.storage.set(this.name, newState);
-  }
-  async doClear() {
-    this.storage.delete(this.name);
-  }
-  async doKeys() {
-    const state = this.storage.get(this.name);
-    if (!state) return [];
-    return this.getAllKeys(state);
-  }
-  async doHas(key) {
-    const value = await this.doGet(key);
-    return value !== void 0;
-  }
-  async doDestroy() {
-    this.storage.delete(this.name);
-  }
-  getAllKeys(obj) {
-    return Object.keys(obj);
-  }
-};
-
-// src/reactive/dispatcher/dispatcher.module.ts
-var import_rxjs = require("rxjs");
-var Dispatcher = class {
-  /**
-   * Создает новый экземпляр Dispatcher
-   */
-  constructor(options) {
-    this.options = options;
-    this.storage = options.storage;
-    this.middlewareAPI = {
-      getState: () => this.storage.getState(),
-      dispatch: async (action) => {
-        this.actions$.next(action);
-        return action.payload;
-      },
-      storage: this.storage,
-      actions$: this.actions,
-      actions: this.dispatch,
-      watchers: this.watchers,
-      findActionByType: (type) => this.findActionByType(type),
-      findWatcherByType: (type) => this.findWatcherByType(type)
-    };
-    if (options.middlewares && options.middlewares.length > 0) {
-      this.use(...options.middlewares);
-    }
-  }
-  // Поток действий
-  actions$ = new import_rxjs.Subject();
-  // Публичный Observable для действий
-  actions = this.actions$.asObservable();
-  // Методы диспетчеризации действий с типизацией
-  dispatch = {};
-  // Watcher'ы для реактивной подписки на изменения
-  watchers = {};
-  // Ссылка на хранилище
-  storage;
-  // Только один массив для хранения инициализированных middleware
-  middlewareFunctions = [];
-  // API для инициализации middleware
-  middlewareAPI;
-  /**
-   * Добавляет middleware в цепочку обработки
-   */
-  use(...middlewares) {
-    for (let i = 0; i < middlewares.length; i++) {
-      try {
-        const initializedMiddleware = middlewares[i](this.middlewareAPI);
-        this.middlewareFunctions.push(initializedMiddleware);
-      } catch (error) {
-        console.error(`Error initializing middleware [${i}]:`, error);
-      }
-    }
-    return this;
-  }
-  /**
-   * Получает все действия с улучшенной типизацией
-   */
-  getActions() {
-    return this.dispatch;
-  }
-  /**
-   * Получает типизированные действия диспетчера
-   */
-  getTypedDispatch() {
-    return this.dispatch;
-  }
-  /**
-   * Получает типизированные watcher'ы
-   */
-  getTypedWatchers() {
-    return this.watchers;
-  }
-  /**
-   * Находит действие по типу
-   */
-  findActionByType(actionType) {
-    return Object.values(this.dispatch).find((action) => {
-      return action.actionType.split(`[${this.storage.name}]`)[1] === actionType;
-    });
-  }
-  /**
-   * Находит наблюдатель по типу
-   */
-  findWatcherByType(actionType) {
-    return Object.values(this.watchers).find((watcher) => watcher.actionType === actionType);
-  }
-  /**
-   * Создает действие
-   */
-  createAction(actionConfig, executionOptions) {
-    const actionType = `[${this.storage.name}]${actionConfig.type}`;
-    let lastArgs = null;
-    let lastResult = null;
-    const dispatchFn = async (params) => {
-      const args = [params];
-      if (executionOptions?.memoize && lastArgs && lastResult) {
-        if (executionOptions.memoize(args, lastArgs, lastResult)) {
-          return lastResult;
-        }
-      }
-      const actionObject = {
-        type: actionType,
-        meta: actionConfig.meta
-      };
-      let result;
-      if (this.middlewareFunctions.length > 0) {
-        let chain = async (action) => {
-          if (executionOptions?.worker) {
-            return this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
-          } else {
-            return Promise.resolve(actionConfig.action(params));
-          }
-        };
-        for (let i = this.middlewareFunctions.length - 1; i >= 0; i--) {
-          const currentMiddleware = this.middlewareFunctions[i];
-          const nextChain = chain;
-          chain = async (action) => {
-            const next = async (nextAction) => nextChain(nextAction);
-            return currentMiddleware(next)(action);
-          };
-        }
-        result = await chain(actionObject);
-      } else {
-        if (executionOptions?.worker) {
-          result = await this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
-        } else {
-          result = await actionConfig.action(params);
-        }
-      }
-      actionObject.payload = result;
-      lastArgs = [...args];
-      lastResult = result;
-      this.actions$.next(actionObject);
-      return result;
-    };
-    dispatchFn._type = "dispatch";
-    Object.defineProperty(dispatchFn, "actionType", {
-      value: actionType,
-      writable: false,
-      enumerable: true
-    });
-    if (actionConfig.meta) {
-      Object.defineProperty(dispatchFn, "meta", {
-        value: actionConfig.meta,
-        writable: false,
-        enumerable: true
-      });
-    }
-    return dispatchFn;
-  }
-  /**
-   * Создает watcher для отслеживания изменений в хранилище
-   */
-  createWatcher(config) {
-    const actionType = `[${this.storage.name}]${config.type}`;
-    const subject = new import_rxjs.Subject();
-    let prevValue;
-    const unsubscribe = this.storage.subscribe(config.selector, (value) => {
-      if (!config.shouldTrigger || config.shouldTrigger(prevValue, value)) {
-        const action = {
-          type: actionType,
-          payload: value,
-          meta: config.meta
-        };
-        this.actions$.next(action);
-        subject.next(action);
-        prevValue = value;
-      }
-    });
-    const watcherFn = () => subject.asObservable();
-    watcherFn._type = "watchers";
-    Object.defineProperty(watcherFn, "actionType", {
-      value: actionType,
-      writable: false,
-      enumerable: true
-    });
-    if (config.meta) {
-      Object.defineProperty(watcherFn, "meta", {
-        value: config.meta,
-        writable: false,
-        enumerable: true
-      });
-    }
-    Object.defineProperty(watcherFn, "unsubscribe", {
-      value: unsubscribe,
-      writable: false,
-      enumerable: true
-    });
-    return watcherFn;
-  }
-  /**
-   * Выполняет действие в worker
-   */
-  async executeInWorker(worker, actionType, args, fallbackAction) {
-    return new Promise((resolve, reject) => {
-      const requestId = `${actionType}_${Date.now()}_${Math.random()}`;
-      const handleMessage = (event) => {
-        if (event.data.requestId === requestId) {
-          worker.removeEventListener("message", handleMessage);
-          if (event.data.error) {
-            reject(new Error(event.data.error));
-          } else {
-            resolve(event.data.result);
-          }
-        }
-      };
-      worker.addEventListener("message", handleMessage);
-      worker.postMessage({
-        type: actionType,
-        args,
-        requestId
-      });
-      setTimeout(() => {
-        worker.removeEventListener("message", handleMessage);
-        reject(new Error(`Worker execution timeout for action: ${actionType}`));
-      }, 3e4);
-    });
-  }
-};
-function createDispatcher(options, actionsSetup) {
-  const dispatcher = new Dispatcher(options);
-  const actions = actionsSetup(options.storage, {
-    createAction: (actionConfig, executionOptions) => dispatcher.createAction(actionConfig, executionOptions),
-    createWatcher: (config) => dispatcher.createWatcher(config)
-  });
-  for (const [key, fn] of Object.entries(actions)) {
-    if (typeof fn === "function") {
-      const type = fn._type;
-      dispatcher[type][key] = fn;
-    }
-  }
-  return dispatcher;
-}
-
-// src/reactive/dispatcher/middlewares/logger.middleware.ts
-function getStateDiff(prevState, nextState) {
-  const diff = {};
-  const allKeys = [.../* @__PURE__ */ new Set([...Object.keys(prevState), ...Object.keys(nextState)])];
-  allKeys.forEach((key) => {
-    if (key in prevState && key in nextState) {
-      if (typeof prevState[key] === "object" && prevState[key] !== null && typeof nextState[key] === "object" && nextState[key] !== null && !Array.isArray(prevState[key]) && !Array.isArray(nextState[key])) {
-        const nestedDiff = getStateDiff(prevState[key], nextState[key]);
-        if (Object.keys(nestedDiff).length > 0) {
-          diff[key] = nestedDiff;
-        }
-      } else if (JSON.stringify(prevState[key]) !== JSON.stringify(nextState[key])) {
-        diff[key] = { PREV: prevState[key], NEXT: nextState[key] };
-      }
-    } else if (key in prevState) {
-      diff[key] = { PREV: prevState[key], NEXT: void 0 };
-    } else {
-      diff[key] = { PREV: void 0, NEXT: nextState[key] };
-    }
-  });
-  return diff;
-}
-var loggerDispatcherMiddleware = (options = {}) => {
-  const defaultTranslations = {
-    action: "\u0414\u0435\u0439\u0441\u0442\u0432\u0438\u0435",
-    prevState: "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
-    nextState: "\u0421\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
-    duration: "\u0414\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
-    error: "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0438",
-    diff: "\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F",
-    changesCount: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439",
-    showFullState: "\u041F\u043E\u043B\u043D\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435"
-  };
-  const defaultOptions = {
-    collapsed: false,
-    duration: true,
-    diff: false,
-    showFullState: true,
-    // Показывать полное состояние по умолчанию
-    translations: defaultTranslations,
-    colors: {
-      title: "#3498db",
-      prevState: "#9E9E9E",
-      fullState: "#008a15",
-      action: "#03A9F4",
-      nextState: "#4CAF50",
-      error: "#F20404",
-      diff: "#9C27B0"
-    }
-  };
-  const mergedOptions = {
-    ...defaultOptions,
-    ...options,
-    // Объединяем переводы отдельно, чтобы позволить частичное переопределение
-    translations: {
-      ...defaultTranslations,
-      ...options.translations || {}
-    },
-    // Объединяем цвета отдельно, чтобы позволить частичное переопределение
-    colors: {
-      ...defaultOptions.colors,
-      ...options.colors || {}
-    }
-  };
-  const { collapsed, duration, colors, translations } = mergedOptions;
-  return (api) => (next) => async (action) => {
-    const started = Date.now();
-    const prevState = await api.getState();
-    try {
-      const result = await next(action);
-      const nextState = await api.getState();
-      const ended = Date.now();
-      const time = ended - started;
-      const title = `${action.type}`;
-      const groupMethod = collapsed ? console.groupCollapsed : console.group;
-      groupMethod(`%c ${title}`, `color: ${colors.title}; font-weight: bold`);
-      console.log(`%c ${translations.action}:`, `color: ${colors.action}; font-weight: bold`, action);
-      if (mergedOptions.diff) {
-        const stateDiff = getStateDiff(prevState, nextState);
-        const changesCount = Object.keys(stateDiff).length;
-        console.log(`%c ${translations.diff} (${translations.changesCount}: ${changesCount}):`, `color: ${colors.diff}; font-weight: bold`, stateDiff);
-      }
-      if (mergedOptions.showFullState) {
-        console.groupCollapsed(`%c ${translations.showFullState}`, `color: ${colors.fullState}; font-weight: bold`);
-        console.log(`%c ${translations.prevState}:`, `color: ${colors.prevState}; font-weight: bold`, prevState);
-        console.log(`%c ${translations.nextState}:`, `color: ${colors.nextState}; font-weight: bold`, nextState);
-        console.groupEnd();
-      }
-      if (duration) {
-        console.log(`%c ${translations.duration}: %c ${time}ms`, "font-weight: bold", "color: #4CAF50");
-      }
-      console.groupEnd();
-      return result;
-    } catch (error) {
-      console.error(`%c ${translations.error}:`, `color: ${colors.error}; font-weight: bold`, action.type, error);
-      throw error;
-    }
-  };
-};
-
-// 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/_utils/chunk.util.ts
-function chunk(array, size = 1) {
-  if (size <= 0) throw new Error("Size must be greater than 0");
-  if (!array || !array.length) return [];
-  const result = [];
-  const length = array.length;
-  let index = 0;
-  while (index < length) {
-    result.push(array.slice(index, index + size));
-    index += size;
-  }
-  return result;
-}
-
-// src/_utils/deepMerge.util.ts
-var deepMerge = (target, source) => {
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
-        if (!target[key] || typeof target[key] !== "object") {
-          target[key] = {};
-        }
-        deepMerge(target[key], source[key]);
-      } else {
-        target[key] = source[key];
-      }
-    }
-  }
-};
-
-// src/reactive/effects/utils/chunkRequestConsistent.ts
-var chunkRequestConsistent = (fn, arr, size, delayMs = 0) => {
-  const chunks = chunk(arr, size).map((chunkItem) => (0, import_rxjs2.of)(chunkItem).pipe((0, import_operators.delay)(delayMs), (0, import_operators.mergeMap)(fn)));
-  return (0, import_rxjs2.of)(...chunks).pipe((0, import_operators.concatAll)(), (0, import_operators.toArray)());
-};
-
-// src/reactive/effects/utils/chunkRequestParallel.ts
-var import_rxjs3 = require("rxjs");
-var import_operators2 = require("rxjs/operators");
-var chunkRequestParallel = (fn, arr, size, delayMs = 0) => (0, import_rxjs3.forkJoin)(chunk(arr, size).map((chunkItem, index) => (0, import_rxjs3.timer)(index * delayMs).pipe((0, import_operators2.mergeMap)(() => fn(chunkItem)))));
-
-// src/reactive/effects/effects.module.ts
-function ofType(actionFn) {
-  const { actionType } = actionFn;
-  if (!actionType) {
-    console.warn("ofType: Action function does not have actionType property", actionFn);
-    return (0, import_operators3.filter)(() => false);
-  }
-  return (source$) => {
-    return source$.pipe((0, import_operators3.filter)((action) => action !== void 0 && action.type === actionType));
-  };
-}
-function ofTypes(actionFns) {
-  const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
-  if (actionTypes.length === 0) {
-    console.warn("ofTypes: No valid action types found in array", actionFns);
-    return (0, import_operators3.filter)(() => false);
-  }
-  return (source$) => {
-    return source$.pipe((0, import_operators3.filter)((action) => action !== void 0 && actionTypes.includes(action.type)));
-  };
-}
-function ofTypesWaitAll(actionFns) {
-  return (source$) => {
-    const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
-    if (actionTypes.length === 0) {
-      console.warn("ofTypesWaitAll: No valid action types found in array", actionFns);
-      return (0, import_rxjs4.of)([]);
-    }
-    const actionStreams = actionTypes.map(
-      (type, index) => source$.pipe(
-        (0, import_operators3.filter)((action) => action.type === type),
-        (0, import_operators3.take)(1),
-        (0, import_operators3.map)(
-          (action) => (
-            // Сохраняем ассоциацию с индексом, чтобы соответствовать
-            // порядку в исходном массиве actionFns
-            { index, action }
-          )
-        )
-      )
-    );
-    return (0, import_rxjs4.combineLatest)(actionStreams).pipe(
-      (0, import_operators3.map)((results) => {
-        results.sort((a, b) => a.index - b.index);
-        return results.map((r) => r.action);
-      })
-    );
-  };
-}
-function selectorMap(state$, ...selectors) {
-  return state$.pipe(
-    (0, import_operators3.map)((state) => {
-      return selectors.map((selector) => selector(state));
-    })
-  );
-}
-function selectorObject(state$, selectors) {
-  return state$.pipe(
-    (0, import_operators3.map)((state) => {
-      const result = {};
-      for (const [key, selector] of Object.entries(selectors)) {
-        result[key] = selector(state);
-      }
-      return result;
-    })
-  );
-}
-function validateMap({
-  validator,
-  apiCall
-}) {
-  return (0, import_rxjs4.pipe)(
-    (0, import_operators3.switchMap)((pipeData) => {
-      const callApi = () => apiCall(pipeData, {
-        chunkRequest: chunkRequestParallel,
-        chunkRequestConsistent
-      });
-      if (!validator) return callApi();
-      const validateConfig = validator(pipeData);
-      const { conditions, skipAction } = validateConfig;
-      const conditionMet = conditions.every(Boolean);
-      if (!conditionMet) {
-        if (Array.isArray(skipAction)) {
-          return (0, import_rxjs4.of)(...skipAction?.filter(Boolean).map((action) => typeof action === "function" ? action() : action));
-        }
-        return (0, import_rxjs4.of)(typeof skipAction === "function" ? skipAction() : skipAction);
-      }
-      return callApi();
-    })
-  );
-}
-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);
-    }
-  }
-};
-function createEffectBase(effect) {
-  return effect;
-}
-function createEffect(effect) {
-  return effect;
-}
-function combineEffects(...effects) {
-  return (action$, state$, externalStates, dispatchers, services, config) => {
-    const outputs = effects.map((effect) => {
-      try {
-        return effect(action$, state$, externalStates, dispatchers, services, config);
-      } catch (error) {
-        console.error("Error in one of combined effects:", error);
-        return (0, import_rxjs4.of)(null);
-      }
-    });
-    return (0, import_rxjs4.merge)(...outputs);
-  };
-}
-
-// 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;
-}
-
-// src/react/hooks/useSelector.ts
-var import_react = require("react");
-var SELECTOR_REGISTRY = /* @__PURE__ */ new Map();
-function useSelector(selector, options) {
-  const [state, setState] = (0, import_react.useState)(options?.initialValue);
-  const [isLoading, setIsLoading] = (0, import_react.useState)(!!options?.withLoading);
-  const prevValueRef = (0, import_react.useRef)(options?.initialValue);
-  const equalsRef = (0, import_react.useRef)(options?.equals || ((a, b) => a === b));
-  const selectorId = selector.getId();
-  const updateComponentState = (newValue) => {
-    if (prevValueRef.current === void 0 || !equalsRef.current(newValue, prevValueRef.current)) {
-      prevValueRef.current = newValue;
-      setState(newValue);
-    }
-  };
-  (0, import_react.useEffect)(() => {
-    if (!SELECTOR_REGISTRY.has(selectorId)) {
-      SELECTOR_REGISTRY.set(selectorId, {
-        lastValue: void 0,
-        listeners: /* @__PURE__ */ new Set(),
-        unsubscribe: null
-      });
-    }
-    const registry = SELECTOR_REGISTRY.get(selectorId);
-    registry.listeners.add(updateComponentState);
-    if (registry.lastValue !== void 0) {
-      updateComponentState(registry.lastValue);
-      if (options?.withLoading) {
-        setIsLoading(false);
-      }
-    } else {
-      if (options?.withLoading) setIsLoading(true);
-      selector.select().then((initialValue) => {
-        registry.lastValue = initialValue;
-        registry.listeners.forEach((listener) => listener(initialValue));
-        if (options?.withLoading) setIsLoading(false);
-      }).catch((error) => {
-        console.error(`useSelector: \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u0438\u0438 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u0434\u043B\u044F ${selectorId}`, error);
-        if (options?.withLoading) setIsLoading(false);
-      });
-    }
-    if (!registry.unsubscribe) {
-      registry.unsubscribe = selector.subscribe({
-        notify: (newValue) => {
-          registry.lastValue = newValue;
-          registry.listeners.forEach((listener) => {
-            try {
-              listener(newValue);
-            } catch (error) {
-              console.error(`useSelector: \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438 \u0441\u043B\u0443\u0448\u0430\u0442\u0435\u043B\u044F \u0434\u043B\u044F ${selectorId}`, error);
-            }
-          });
-        }
-      });
-    }
-    return () => {
-      const registry2 = SELECTOR_REGISTRY.get(selectorId);
-      if (registry2) {
-        registry2.listeners.delete(updateComponentState);
-        if (registry2.listeners.size === 0) {
-          if (registry2.unsubscribe) {
-            registry2.unsubscribe();
-          }
-          SELECTOR_REGISTRY.delete(selectorId);
-        }
-      }
-    };
-  }, [selector, selectorId]);
-  if (options?.withLoading) {
-    return { data: state, isLoading };
-  }
-  return state;
-}
-
-// src/react/hooks/useStorageSubscribe.ts
-var import_react2 = require("react");
-var useStorageSubscribe = (storage, selector) => {
-  const [value, setValue] = (0, import_react2.useState)(void 0);
-  (0, import_react2.useEffect)(() => {
-    let isMounted = true;
-    const initializeValue = async () => {
-      try {
-        const state = await storage.getState();
-        const selectedValue = selector(state);
-        if (isMounted) {
-          setValue(selectedValue);
-        }
-      } catch (error) {
-        console.error("Failed to initialize storage value:", error);
-      }
-    };
-    initializeValue();
-    let unsubscribe;
-    try {
-      unsubscribe = storage.subscribe(selector, (newValue) => {
-        if (isMounted) {
-          setValue(newValue);
-        }
-      });
-    } catch (error) {
-      console.error("Failed to subscribe to storage:", error);
-      unsubscribe = () => {
-      };
-    }
-    return () => {
-      isMounted = false;
-      unsubscribe();
-    };
-  }, [storage, selector]);
-  return value;
-};
-
-// src/react/utils/createSynapseCtx.tsx
-var import_react3 = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
-var ERROR_HOOK_MESSAGE = "useSynapseActions \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442\u0430 contextSynapse";
-var ERROR_CONTEXT_INIT = "\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430:";
-function createSynapseCtx(synapseStorePromise, options) {
-  const { loadingComponent = null, mergeFn = deepMerge } = options || {};
-  let synapseStore = null;
-  let storeReady = false;
-  const initPromise = (async () => {
-    try {
-      synapseStore = await (synapseStorePromise instanceof Promise ? synapseStorePromise : Promise.resolve(synapseStorePromise));
-      storeReady = true;
-    } catch (error) {
-      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 Synapse:", error);
-    }
-  })();
-  const SynapseContext = (0, import_react3.createContext)(null);
-  const useSynapseStorage = () => {
-    const context = (0, import_react3.useContext)(SynapseContext);
-    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
-    return context.storage;
-  };
-  const useSynapseSelectors = () => {
-    const context = (0, import_react3.useContext)(SynapseContext);
-    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
-    return context.selectors;
-  };
-  const useSynapseActions = () => {
-    const context = (0, import_react3.useContext)(SynapseContext);
-    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
-    if ("actions" in context) {
-      return context.actions;
-    }
-    throw new Error("useSynapseActions: actions \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0442\u0438\u043F\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430. \u0423\u0431\u0435\u0434\u0438\u0442\u0435\u0441\u044C, \u0447\u0442\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u0430 \u0444\u0443\u043D\u043A\u0446\u0438\u044F createDispatcherFn \u043F\u0440\u0438 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430.");
-  };
-  const useSynapseState$ = () => {
-    const context = (0, import_react3.useContext)(SynapseContext);
-    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
-    if ("state$" in context) {
-      return context.state$;
-    }
-    throw new Error("useSynapseState$: state$ \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0442\u0438\u043F\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430. \u0423\u0431\u0435\u0434\u0438\u0442\u0435\u0441\u044C, \u0447\u0442\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u044B \u0444\u0443\u043D\u043A\u0446\u0438\u0438 createDispatcherFn \u0438 createEffectConfig \u043F\u0440\u0438 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430.");
-  };
-  function contextSynapse(Component) {
-    function WrappedComponent({ contextProps, ...props }) {
-      const [initialized, setInitialized] = (0, import_react3.useState)(false);
-      const [storeInitialized, setStoreInitialized] = (0, import_react3.useState)(storeReady);
-      const debugIdRef = (0, import_react3.useRef)(`synapse-${synapseStore?.storage.name || "initializing"}`);
-      (0, import_react3.useEffect)(() => {
-        if (!storeReady) {
-          initPromise.then(() => {
-            setStoreInitialized(true);
-          });
-        }
-      }, []);
-      (0, import_react3.useEffect)(() => {
-        if (!storeInitialized) return;
-        let mounted = true;
-        const initializeContext = async () => {
-          try {
-            if (synapseStore && contextProps && Object.keys(contextProps).length > 0) {
-              await synapseStore.storage.update((state) => {
-                mergeFn(state, contextProps);
-              });
-            }
-            if (mounted) {
-              setInitialized(true);
-            }
-          } catch (error) {
-            console.error(`[${debugIdRef.current}] ${ERROR_CONTEXT_INIT}`, error);
-          }
-        };
-        initializeContext();
-        return () => {
-          mounted = false;
-        };
-      }, [contextProps, storeInitialized]);
-      if (!storeInitialized) {
-        return loadingComponent || /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430..." });
-      }
-      if (!initialized) {
-        return loadingComponent || /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "\u0418\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430..." });
-      }
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SynapseContext.Provider, { value: synapseStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...props }) });
-    }
-    const componentName = Component.displayName || Component.name || "Component";
-    WrappedComponent.displayName = `SynapseContext(${componentName})`;
-    return WrappedComponent;
-  }
-  const cleanupSynapse = async () => {
-    await initPromise;
-    return synapseStore?.destroy() || Promise.resolve();
-  };
-  return {
-    contextSynapse,
-    useSynapseStorage,
-    useSynapseSelectors,
-    useSynapseActions,
-    useSynapseState$,
-    cleanupSynapse
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ApiClient,
-  Dispatcher,
-  EffectsModule,
-  IndexedDBStorage,
-  LocalStorage,
-  MemoryStorage,
-  ResponseFormat,
-  SelectorModule,
-  StorageEvents,
-  StoragePluginModule,
-  apiLogger,
-  broadcastMiddleware,
-  combineEffects,
-  createDispatcher,
-  createEffect,
-  createEffectBase,
-  createSynapse,
-  createSynapseCtx,
-  createUniqueId,
-  headersToObject,
-  loggerDispatcherMiddleware,
-  ofType,
-  ofTypes,
-  ofTypesWaitAll,
-  selectorMap,
-  selectorObject,
-  useSelector,
-  useStorageSubscribe,
-  validateMap
-});
-//# sourceMappingURL=index.cjs.map
+'use strict';var chunk22J2S57D_cjs=require('./chunk-22J2S57D.cjs'),chunkFW5NGLPP_cjs=require('./chunk-FW5NGLPP.cjs'),chunkWC5TDS6C_cjs=require('./chunk-WC5TDS6C.cjs'),chunkVSIVOWZF_cjs=require('./chunk-VSIVOWZF.cjs'),chunkUFBCZ25Y_cjs=require('./chunk-UFBCZ25Y.cjs');require('./chunk-635Q6YJZ.cjs'),require('./chunk-NMDHQXMS.cjs');Object.defineProperty(exports,"ApiClient",{enumerable:true,get:function(){return chunk22J2S57D_cjs.e}});Object.defineProperty(exports,"ResponseFormat",{enumerable:true,get:function(){return chunk22J2S57D_cjs.d}});Object.defineProperty(exports,"apiLogger",{enumerable:true,get:function(){return chunk22J2S57D_cjs.a}});Object.defineProperty(exports,"createUniqueId",{enumerable:true,get:function(){return chunk22J2S57D_cjs.b}});Object.defineProperty(exports,"headersToObject",{enumerable:true,get:function(){return chunk22J2S57D_cjs.c}});Object.defineProperty(exports,"createSynapseCtx",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.c}});Object.defineProperty(exports,"useSelector",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.a}});Object.defineProperty(exports,"useStorageSubscribe",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.b}});Object.defineProperty(exports,"createSynapse",{enumerable:true,get:function(){return chunkWC5TDS6C_cjs.a}});Object.defineProperty(exports,"IndexedDBStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.e}});Object.defineProperty(exports,"LocalStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.f}});Object.defineProperty(exports,"MemoryStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.g}});Object.defineProperty(exports,"SelectorModule",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.a}});Object.defineProperty(exports,"StorageEvents",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.c}});Object.defineProperty(exports,"StoragePluginModule",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.b}});Object.defineProperty(exports,"broadcastMiddleware",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.d}});Object.defineProperty(exports,"Dispatcher",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.a}});Object.defineProperty(exports,"EffectsModule",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.j}});Object.defineProperty(exports,"combineEffects",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.m}});Object.defineProperty(exports,"createDispatcher",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.b}});Object.defineProperty(exports,"createEffect",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.l}});Object.defineProperty(exports,"createEffectBase",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.k}});Object.defineProperty(exports,"loggerDispatcherMiddleware",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.c}});Object.defineProperty(exports,"ofType",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.d}});Object.defineProperty(exports,"ofTypes",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.e}});Object.defineProperty(exports,"ofTypesWaitAll",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.f}});Object.defineProperty(exports,"selectorMap",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.g}});Object.defineProperty(exports,"selectorObject",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.h}});Object.defineProperty(exports,"validateMap",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.i}});