@djangocfg/monitor 2.1.216

package/dist/client.cjs

@@ -0,0 +1,1273 @@
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  FrontendMonitor: () => FrontendMonitor,
+  getSessionId: () => getSessionId,
+  monitoredFetch: () => monitoredFetch
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/capture/fingerprint.ts
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+__name(simpleHash, "simpleHash");
+async function computeFingerprint(message, stack, url) {
+  const raw = `${message}|${stack}|${url}`;
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    try {
+      const data = new TextEncoder().encode(raw);
+      const buf = await crypto.subtle.digest("SHA-256", data);
+      return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 64);
+    } catch {
+    }
+  }
+  return simpleHash(raw);
+}
+__name(computeFingerprint, "computeFingerprint");
+
+// src/client/capture/session.ts
+var SESSION_KEY = "fm_session_id";
+var COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+__name(generateUUID, "generateUUID");
+function setCookie(name, value) {
+  if (typeof document === "undefined") return;
+  document.cookie = `${name}=${value}; path=/; SameSite=Lax; max-age=${COOKIE_MAX_AGE}`;
+}
+__name(setCookie, "setCookie");
+function getSessionId() {
+  if (typeof localStorage === "undefined") return "";
+  let id = localStorage.getItem(SESSION_KEY);
+  if (!id) {
+    id = generateUUID();
+    localStorage.setItem(SESSION_KEY, id);
+    setCookie(SESSION_KEY, id);
+  }
+  return id;
+}
+__name(getSessionId, "getSessionId");
+function ensureSessionCookie() {
+  const id = getSessionId();
+  if (id) setCookie(SESSION_KEY, id);
+}
+__name(ensureSessionCookie, "ensureSessionCookie");
+
+// src/client/store/index.ts
+var import_vanilla = require("zustand/vanilla");
+
+// src/_api/generated/cfg_monitor/monitor/client.ts
+var _Monitor = class _Monitor {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Ingest browser events
+   * 
+   * Accepts a batch of up to 50 frontend events. No authentication required.
+   */
+  async ingestCreate(data) {
+    const response = await this.client.request("POST", "/cfg/monitor/ingest/", { body: data });
+    return response;
+  }
+};
+__name(_Monitor, "Monitor");
+var Monitor = _Monitor;
+
+// src/_api/generated/cfg_monitor/http.ts
+var _FetchAdapter = class _FetchAdapter {
+  async request(request) {
+    const { method, url, headers, body, params, formData, binaryBody } = request;
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+    const finalHeaders = { ...headers };
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
+    } else if (body) {
+      finalHeaders["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
+    }
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: "include"
+      // Include Django session cookies
+    });
+    let data = null;
+    const contentType = response.headers.get("content-type");
+    if (response.status !== 204 && contentType?.includes("application/json")) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+__name(_FetchAdapter, "FetchAdapter");
+var FetchAdapter = _FetchAdapter;
+var _KeepAliveFetchAdapter = class _KeepAliveFetchAdapter extends FetchAdapter {
+  async request(request) {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (input, init) => origFetch(input, { ...init, keepalive: true });
+    try {
+      return await super.request(request);
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  }
+};
+__name(_KeepAliveFetchAdapter, "KeepAliveFetchAdapter");
+var KeepAliveFetchAdapter = _KeepAliveFetchAdapter;
+
+// src/_api/generated/cfg_monitor/errors.ts
+var _APIError = class _APIError extends Error {
+  constructor(statusCode, statusText, response, url, message) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.response = response;
+    this.url = url;
+    this.name = "APIError";
+  }
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details() {
+    if (typeof this.response === "object" && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors() {
+    const details = this.details;
+    if (!details) return null;
+    const fieldErrors = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage() {
+    const details = this.details;
+    if (!details) return this.message;
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
+    }
+    if (details.message) {
+      return String(details.message);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // Helper methods for common HTTP status codes
+  get isValidationError() {
+    return this.statusCode === 400;
+  }
+  get isAuthError() {
+    return this.statusCode === 401;
+  }
+  get isPermissionError() {
+    return this.statusCode === 403;
+  }
+  get isNotFoundError() {
+    return this.statusCode === 404;
+  }
+  get isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+};
+__name(_APIError, "APIError");
+var APIError = _APIError;
+var _NetworkError = class _NetworkError extends Error {
+  constructor(message, url, originalError) {
+    super(message);
+    this.url = url;
+    this.originalError = originalError;
+    this.name = "NetworkError";
+  }
+};
+__name(_NetworkError, "NetworkError");
+var NetworkError = _NetworkError;
+
+// src/_api/generated/cfg_monitor/logger.ts
+var import_consola = require("consola");
+var DEFAULT_CONFIG = {
+  enabled: true,
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var _APILogger = class _APILogger {
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || (0, import_consola.createConsola)({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    const statusColor = status >= 500 ? "red" : status >= 400 ? "yellow" : status >= 300 ? "cyan" : "green";
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
+    }
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+__name(_APILogger, "APILogger");
+var APILogger = _APILogger;
+var defaultLogger = new APILogger();
+
+// src/_api/generated/cfg_monitor/retry.ts
+var import_p_retry = __toESM(require("p-retry"), 1);
+var DEFAULT_RETRY_CONFIG = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: /* @__PURE__ */ __name(() => {
+  }, "onFailedAttempt")
+};
+function shouldRetry(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+__name(shouldRetry, "shouldRetry");
+async function withRetry(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return (0, import_p_retry.default)(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new import_p_retry.AbortError(error);
+        }
+        throw error;
+      }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        const pRetryError = error;
+        finalConfig.onFailedAttempt({
+          error: pRetryError,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft
+        });
+      } : void 0
+    }
+  );
+}
+__name(withRetry, "withRetry");
+
+// src/_api/generated/cfg_monitor/client.ts
+var _APIClient = class _APIClient {
+  constructor(baseUrl, options) {
+    this.logger = null;
+    this.retryConfig = null;
+    this.tokenGetter = null;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    this.tokenGetter = options?.tokenGetter || null;
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.monitor = new Monitor(this);
+  }
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken() {
+    const name = "csrftoken";
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(";").shift() || null;
+    }
+    return null;
+  }
+  /**
+   * Get the base URL for building streaming/download URLs.
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get JWT token for URL authentication (used in streaming endpoints).
+   * Returns null if no token getter is configured or no token is available.
+   */
+  getToken() {
+    return this.tokenGetter ? this.tokenGetter() : null;
+  }
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request(method, path, options) {
+    if (this.retryConfig) {
+      return withRetry(() => this._makeRequest(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: /* @__PURE__ */ __name((info) => {
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          this.retryConfig?.onFailedAttempt?.(info);
+        }, "onFailedAttempt")
+      });
+    }
+    return this._makeRequest(method, path, options);
+  }
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  async _makeRequest(method, path, options) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const startTime = Date.now();
+    const headers = {
+      ...options?.headers || {}
+    };
+    if (!options?.formData && !options?.binaryBody && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime
+      });
+    }
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData,
+        binaryBody: options?.binaryBody
+      });
+      const duration = Date.now() - startTime;
+      if (response.status >= 400) {
+        const error = new APIError(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now()
+            }
+          );
+        }
+        throw error;
+      }
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      return response.data;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof APIError) {
+        throw error;
+      }
+      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (typeof window !== "undefined") {
+        try {
+          if (isCORSError) {
+            window.dispatchEvent(new CustomEvent("cors-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          } else {
+            window.dispatchEvent(new CustomEvent("network-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          }
+        } catch (eventError) {
+        }
+      }
+      const networkError = error instanceof Error ? new NetworkError(error.message, url, error) : new NetworkError("Unknown error", url);
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      throw networkError;
+    }
+  }
+};
+__name(_APIClient, "APIClient");
+var APIClient = _APIClient;
+
+// src/_api/generated/cfg_monitor/storage.ts
+var _LocalStorageAdapter = class _LocalStorageAdapter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  getItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+        return value;
+      }
+      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+    } catch (error) {
+      this.logger?.error("LocalStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.removeItem failed:", error);
+    }
+  }
+};
+__name(_LocalStorageAdapter, "LocalStorageAdapter");
+var LocalStorageAdapter = _LocalStorageAdapter;
+var _MemoryStorageAdapter = class _MemoryStorageAdapter {
+  constructor(logger) {
+    this.storage = /* @__PURE__ */ new Map();
+    this.logger = logger;
+  }
+  getItem(key) {
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+    return value;
+  }
+  setItem(key, value) {
+    this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
+  }
+  removeItem(key) {
+    this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
+  }
+};
+__name(_MemoryStorageAdapter, "MemoryStorageAdapter");
+var MemoryStorageAdapter = _MemoryStorageAdapter;
+
+// src/_api/generated/cfg_monitor/enums.ts
+var FrontendEventIngestRequestEventType = /* @__PURE__ */ ((FrontendEventIngestRequestEventType2) => {
+  FrontendEventIngestRequestEventType2["ERROR"] = "ERROR";
+  FrontendEventIngestRequestEventType2["WARNING"] = "WARNING";
+  FrontendEventIngestRequestEventType2["INFO"] = "INFO";
+  FrontendEventIngestRequestEventType2["PAGE_VIEW"] = "PAGE_VIEW";
+  FrontendEventIngestRequestEventType2["PERFORMANCE"] = "PERFORMANCE";
+  FrontendEventIngestRequestEventType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  FrontendEventIngestRequestEventType2["JS_ERROR"] = "JS_ERROR";
+  FrontendEventIngestRequestEventType2["CONSOLE"] = "CONSOLE";
+  return FrontendEventIngestRequestEventType2;
+})(FrontendEventIngestRequestEventType || {});
+var FrontendEventIngestRequestLevel = /* @__PURE__ */ ((FrontendEventIngestRequestLevel2) => {
+  FrontendEventIngestRequestLevel2["ERROR"] = "error";
+  FrontendEventIngestRequestLevel2["WARN"] = "warn";
+  FrontendEventIngestRequestLevel2["INFO"] = "info";
+  FrontendEventIngestRequestLevel2["DEBUG"] = "debug";
+  return FrontendEventIngestRequestLevel2;
+})(FrontendEventIngestRequestLevel || {});
+
+// src/_api/generated/cfg_monitor/_utils/schemas/FrontendEventIngestRequest.schema.ts
+var import_zod = require("zod");
+var FrontendEventIngestRequestSchema = import_zod.z.object({
+  event_type: import_zod.z.nativeEnum(FrontendEventIngestRequestEventType),
+  message: import_zod.z.string().min(1).max(5e3),
+  level: import_zod.z.nativeEnum(FrontendEventIngestRequestLevel).optional(),
+  stack_trace: import_zod.z.string().max(2e4).optional(),
+  url: import_zod.z.string().max(2e3).optional(),
+  fingerprint: import_zod.z.string().max(64).optional(),
+  http_status: import_zod.z.number().int().nullable().optional(),
+  http_method: import_zod.z.string().max(10).optional(),
+  http_url: import_zod.z.string().max(2e3).optional(),
+  user_agent: import_zod.z.string().max(500).optional(),
+  session_id: import_zod.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).nullable().optional(),
+  browser_fingerprint: import_zod.z.string().max(64).optional(),
+  extra: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  project_name: import_zod.z.string().max(100).optional(),
+  environment: import_zod.z.string().max(20).optional()
+});
+
+// src/_api/generated/cfg_monitor/_utils/schemas/IngestBatchRequest.schema.ts
+var import_zod2 = require("zod");
+var IngestBatchRequestSchema = import_zod2.z.object({
+  events: import_zod2.z.array(FrontendEventIngestRequestSchema)
+});
+
+// src/_api/generated/cfg_monitor/index.ts
+var TOKEN_KEY = "auth_token";
+var REFRESH_TOKEN_KEY = "refresh_token";
+function detectLocale() {
+  try {
+    if (typeof document !== "undefined") {
+      const match = document.cookie.match(/(?:^|;\s*)NEXT_LOCALE=([^;]*)/);
+      if (match) return match[1];
+    }
+    if (typeof navigator !== "undefined" && navigator.language) {
+      return navigator.language;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(detectLocale, "detectLocale");
+var _API = class _API {
+  constructor(baseUrl, options) {
+    this._token = null;
+    this._refreshToken = null;
+    this._locale = null;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger);
+    this._locale = options?.locale || null;
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      httpClient: this.options?.httpClient,
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig,
+      tokenGetter: /* @__PURE__ */ __name(() => this.getToken(), "tokenGetter")
+    });
+    this._injectAuthHeader();
+    this.monitor = this._client.monitor;
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  _reinitClients() {
+    this._client = new APIClient(this.baseUrl, {
+      httpClient: this.options?.httpClient,
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig,
+      tokenGetter: /* @__PURE__ */ __name(() => this.getToken(), "tokenGetter")
+    });
+    this._injectAuthHeader();
+    this.monitor = this._client.monitor;
+  }
+  _injectAuthHeader() {
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async (method, path, options) => {
+      const token = this.getToken();
+      const locale = this._locale || detectLocale();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...options?.headers || {},
+          ...token ? { "Authorization": `Bearer ${token}` } : {},
+          ...locale ? { "Accept-Language": locale } : {}
+        }
+      };
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+  /**
+   * Get current JWT token
+   */
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token, refreshToken) {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+    this._reinitClients();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.getToken();
+  }
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url;
+    this._reinitClients();
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Set locale for Accept-Language header
+   * @param locale - Locale string (e.g. 'en', 'ko', 'ru') or null to clear
+   */
+  setLocale(locale) {
+    this._locale = locale;
+  }
+  /**
+   * Get current locale
+   */
+  getLocale() {
+    return this._locale;
+  }
+  /**
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
+   */
+  getSchemaPath() {
+    return "./schema.json";
+  }
+};
+__name(_API, "API");
+var API = _API;
+
+// src/_api/BaseClient.ts
+var monitorApi = new API("", { storage: new MemoryStorageAdapter() });
+function configureMonitorApi(baseUrl) {
+  monitorApi.setBaseUrl(baseUrl);
+}
+__name(configureMonitorApi, "configureMonitorApi");
+var _BaseClient = class _BaseClient {
+};
+__name(_BaseClient, "BaseClient");
+_BaseClient.monitorApi = monitorApi;
+var BaseClient = _BaseClient;
+
+// src/client/transport/ingest.ts
+var monitorApiBeacon = new API("", {
+  storage: new MemoryStorageAdapter(),
+  httpClient: new KeepAliveFetchAdapter()
+});
+function syncBeaconBaseUrl() {
+  monitorApiBeacon.setBaseUrl(monitorApi.getBaseUrl());
+}
+__name(syncBeaconBaseUrl, "syncBeaconBaseUrl");
+async function sendBatch(batch, useBeacon = false) {
+  if (batch.events.length === 0) return;
+  try {
+    if (useBeacon) {
+      syncBeaconBaseUrl();
+      await monitorApiBeacon.monitor.ingestCreate(batch);
+    } else {
+      await monitorApi.monitor.ingestCreate(batch);
+    }
+  } catch {
+  }
+}
+__name(sendBatch, "sendBatch");
+
+// src/client/store/index.ts
+var monitorStore = (0, import_vanilla.createStore)((set, get) => ({
+  config: {},
+  buffer: [],
+  initialized: false,
+  push(event) {
+    const { config, buffer } = get();
+    const maxSize = config.maxBufferSize ?? 20;
+    const next = [...buffer, event];
+    set({ buffer: next });
+    if (next.length >= maxSize || event.level === "error") {
+      get().flush();
+    }
+  },
+  flush(useBeacon = false) {
+    const { buffer } = get();
+    if (buffer.length === 0) return;
+    const batch = buffer.slice(0, 50);
+    set({ buffer: buffer.slice(50) });
+    sendBatch({ events: batch }, useBeacon);
+  },
+  setConfig(config) {
+    set({ config, initialized: true });
+  }
+}));
+
+// src/client/capture/js-errors.ts
+function installJsErrorCapture() {
+  if (typeof window === "undefined") return () => {
+  };
+  const onError = /* @__PURE__ */ __name(async (message, source, lineno, colno, error) => {
+    try {
+      const msg = typeof message === "string" ? message : String(message);
+      const stack = error?.stack ?? `at ${source}:${lineno}:${colno}`;
+      const url = window.location.href;
+      const fingerprint = await computeFingerprint(msg, stack, url);
+      const { config } = monitorStore.getState();
+      monitorStore.getState().push({
+        event_type: "JS_ERROR" /* JS_ERROR */,
+        level: "error" /* ERROR */,
+        message: msg,
+        stack_trace: stack,
+        url,
+        fingerprint,
+        session_id: getSessionId(),
+        user_agent: navigator.userAgent,
+        project_name: config.project,
+        environment: config.environment
+      });
+    } catch {
+    }
+  }, "onError");
+  const onUnhandledRejection = /* @__PURE__ */ __name(async (e) => {
+    try {
+      const reason = e.reason;
+      const msg = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
+      const stack = reason instanceof Error ? reason.stack ?? "" : "";
+      const url = window.location.href;
+      const fingerprint = await computeFingerprint(msg, stack, url);
+      const { config } = monitorStore.getState();
+      monitorStore.getState().push({
+        event_type: "JS_ERROR" /* JS_ERROR */,
+        level: "error" /* ERROR */,
+        message: msg,
+        stack_trace: stack,
+        url,
+        fingerprint,
+        session_id: getSessionId(),
+        user_agent: navigator.userAgent,
+        project_name: config.project,
+        environment: config.environment
+      });
+    } catch {
+    }
+  }, "onUnhandledRejection");
+  const errHandler = /* @__PURE__ */ __name((e) => onError(e.message, e.filename, e.lineno, e.colno, e.error), "errHandler");
+  window.addEventListener("error", errHandler);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", errHandler);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+__name(installJsErrorCapture, "installJsErrorCapture");
+
+// src/client/capture/console.ts
+var levelMap = {
+  warn: "warn" /* WARN */,
+  error: "error" /* ERROR */
+};
+var typeMap = {
+  warn: "WARNING" /* WARNING */,
+  error: "ERROR" /* ERROR */
+};
+function stringify(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    if (a instanceof Error) return a.message;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+__name(stringify, "stringify");
+async function captureConsoleEvent(level, args) {
+  try {
+    const message = stringify(args);
+    const url = typeof window !== "undefined" ? window.location.href : "";
+    const fingerprint = await computeFingerprint(message, "", url);
+    const { config } = monitorStore.getState();
+    monitorStore.getState().push({
+      event_type: typeMap[level],
+      level: levelMap[level],
+      message,
+      url,
+      fingerprint,
+      session_id: getSessionId(),
+      user_agent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+      project_name: config.project,
+      environment: config.environment
+    });
+  } catch {
+  }
+}
+__name(captureConsoleEvent, "captureConsoleEvent");
+function installConsoleCapture() {
+  if (typeof window === "undefined") return () => {
+  };
+  try {
+    const g = globalThis;
+    if (g.consola && typeof g.consola.addReporter === "function") {
+      const consolaInst = g.consola;
+      const reporter = {
+        log(logObj) {
+          if (logObj.level === 1) captureConsoleEvent("error", logObj.args);
+          else if (logObj.level === 2) captureConsoleEvent("warn", logObj.args);
+        }
+      };
+      consolaInst.addReporter(reporter);
+      return () => consolaInst.removeReporter(reporter);
+    }
+  } catch {
+  }
+  const origWarn = console.warn.bind(console);
+  const origError = console.error.bind(console);
+  console.warn = (...args) => {
+    origWarn(...args);
+    captureConsoleEvent("warn", args);
+  };
+  console.error = (...args) => {
+    origError(...args);
+    captureConsoleEvent("error", args);
+  };
+  return () => {
+    console.warn = origWarn;
+    console.error = origError;
+  };
+}
+__name(installConsoleCapture, "installConsoleCapture");
+
+// src/client/capture/validation.ts
+function installValidationCapture() {
+  if (typeof window === "undefined") return () => {
+  };
+  const handler = /* @__PURE__ */ __name((event) => {
+    if (!(event instanceof CustomEvent)) return;
+    try {
+      const detail = event.detail;
+      const { config } = monitorStore.getState();
+      monitorStore.getState().push({
+        event_type: "WARNING" /* WARNING */,
+        level: "warn" /* WARN */,
+        message: `Zod validation error in ${detail.operation}: ${detail.error?.message ?? "unknown"}`,
+        url: window.location.href,
+        http_method: detail.method,
+        http_url: detail.path,
+        session_id: getSessionId(),
+        user_agent: navigator.userAgent,
+        project_name: config.project,
+        environment: config.environment,
+        extra: { operation: detail.operation, path: detail.path, method: detail.method }
+      });
+    } catch {
+    }
+  }, "handler");
+  window.addEventListener("zod-validation-error", handler);
+  return () => window.removeEventListener("zod-validation-error", handler);
+}
+__name(installValidationCapture, "installValidationCapture");
+
+// src/client/capture/network.ts
+async function monitoredFetch(input, init) {
+  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+  const method = (init?.method ?? "GET").toUpperCase();
+  try {
+    const response = await fetch(input, init);
+    if (!response.ok) {
+      const { config } = monitorStore.getState();
+      monitorStore.getState().push({
+        event_type: "NETWORK_ERROR" /* NETWORK_ERROR */,
+        level: response.status >= 500 ? "error" /* ERROR */ : "warn" /* WARN */,
+        message: `HTTP ${response.status} ${response.statusText} \u2014 ${method} ${url}`,
+        url: typeof window !== "undefined" ? window.location.href : "",
+        http_status: response.status,
+        http_method: method,
+        http_url: url,
+        session_id: getSessionId(),
+        user_agent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+        project_name: config.project,
+        environment: config.environment
+      });
+    }
+    return response;
+  } catch (err) {
+    const { config } = monitorStore.getState();
+    monitorStore.getState().push({
+      event_type: "NETWORK_ERROR" /* NETWORK_ERROR */,
+      level: "error" /* ERROR */,
+      message: err instanceof Error ? err.message : `Network error \u2014 ${method} ${url}`,
+      url: typeof window !== "undefined" ? window.location.href : "",
+      http_method: method,
+      http_url: url,
+      session_id: getSessionId(),
+      user_agent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+      project_name: config.project,
+      environment: config.environment
+    });
+    throw err;
+  }
+}
+__name(monitoredFetch, "monitoredFetch");
+
+// src/client/index.ts
+var flushInterval = null;
+var cleanupFns = [];
+var FrontendMonitor = {
+  init(config = {}) {
+    if (typeof window === "undefined") return;
+    if (config.baseUrl) configureMonitorApi(config.baseUrl);
+    monitorStore.getState().setConfig(config);
+    ensureSessionCookie();
+    if (config.captureJsErrors !== false) cleanupFns.push(installJsErrorCapture());
+    if (config.captureConsole !== false) cleanupFns.push(installConsoleCapture());
+    cleanupFns.push(installValidationCapture());
+    const interval = config.flushInterval ?? 5e3;
+    flushInterval = setInterval(() => monitorStore.getState().flush(), interval);
+    const onHide = /* @__PURE__ */ __name(() => {
+      if (document.visibilityState === "hidden") monitorStore.getState().flush(true);
+    }, "onHide");
+    window.addEventListener("visibilitychange", onHide);
+    window.addEventListener("beforeunload", () => monitorStore.getState().flush(true));
+    if (config.debug) console.info("[FrontendMonitor] initialized", config);
+  },
+  capture(event) {
+    monitorStore.getState().push(event);
+  },
+  flush() {
+    monitorStore.getState().flush();
+  },
+  destroy() {
+    if (flushInterval !== null) {
+      clearInterval(flushInterval);
+      flushInterval = null;
+    }
+    cleanupFns.forEach((fn) => fn());
+    cleanupFns.length = 0;
+  }
+};
+//# sourceMappingURL=client.cjs.map