synapse-storage 3.0.5 → 3.0.8

package/dist/api.js

@@ -1 +1,859 @@
-export{e as ApiClient,d as ResponseFormat,a as apiLogger,b as createUniqueId,c as headersToObject}from'./chunk-4USKKL5R.js';import'./chunk-ZE2EJX2Y.js';
+// 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();
+  }
+};
+export {
+  ApiClient,
+  ResponseFormat,
+  apiLogger,
+  createUniqueId,
+  headersToObject
+};