@scoperat/tracker 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,3 +1,778 @@
-import scoperat from "./client.js";
-export default scoperat;
+// src/breadcrumbs.ts
+var MAX_BREADCRUMBS = 20;
+var MAX_TEXT_LENGTH = 120;
+var buffer = [];
+var installed = false;
+function push(crumb) {
+  buffer.push(crumb);
+  if (buffer.length > MAX_BREADCRUMBS) {
+    buffer = buffer.slice(-MAX_BREADCRUMBS);
+  }
+}
+function truncate(str, max = MAX_TEXT_LENGTH) {
+  return str.length > max ? str.slice(0, max) + "\u2026" : str;
+}
+function getBreadcrumbs() {
+  return [...buffer];
+}
+function addBreadcrumb(crumb) {
+  push(crumb);
+}
+function startBreadcrumbCollection() {
+  if (installed || typeof window === "undefined") return;
+  installed = true;
+  document.addEventListener(
+    "click",
+    (e) => {
+      const target = e.target;
+      if (!target) return;
+      const text = target.textContent?.trim() || target.getAttribute("aria-label") || "";
+      push({
+        type: "user",
+        category: "click",
+        message: truncate(
+          `${target.tagName.toLowerCase()}${text ? ` "${text}"` : ""}`
+        ),
+        timestamp: Date.now(),
+        data: {
+          tagName: target.tagName.toLowerCase(),
+          className: target.className ? truncate(target.className, 80) : void 0
+        }
+      });
+    },
+    { capture: true }
+  );
+  const origPushState = history.pushState;
+  history.pushState = function(...args) {
+    const from = location.pathname;
+    origPushState.apply(this, args);
+    push({
+      type: "navigation",
+      category: "navigation",
+      message: `${from} \u2192 ${location.pathname}`,
+      timestamp: Date.now()
+    });
+  };
+  window.addEventListener("popstate", () => {
+    push({
+      type: "navigation",
+      category: "navigation",
+      message: `popstate \u2192 ${location.pathname}`,
+      timestamp: Date.now()
+    });
+  });
+  const wrapConsole = (level) => {
+    const orig = console[level];
+    console[level] = (...args) => {
+      push({
+        type: "console",
+        category: `console.${level}`,
+        message: truncate(
+          args.map((a) => typeof a === "string" ? a : String(a)).join(" ")
+        ),
+        timestamp: Date.now()
+      });
+      orig.apply(console, args);
+    };
+  };
+  wrapConsole("error");
+  wrapConsole("warn");
+}
+
+// src/context.ts
+function getBrowserContext() {
+  if (typeof window === "undefined") {
+    return {};
+  }
+  return {
+    page: {
+      url: window.location.href,
+      path: window.location.pathname,
+      title: document.title,
+      referrer: document.referrer || void 0
+    },
+    screen: {
+      width: window.screen.width,
+      height: window.screen.height
+    },
+    locale: navigator.language,
+    userAgent: navigator.userAgent,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+  };
+}
+
+// src/errors.ts
+var DEDUP_COOLDOWN_MS = 6e4;
+var dedupMap = /* @__PURE__ */ new Map();
+function simpleFingerprint(type, stack) {
+  const firstFrame = stack?.split("\n")[1]?.trim() ?? "";
+  return `${type}:${firstFrame}`;
+}
+function isDuplicate(fingerprint) {
+  const lastSent = dedupMap.get(fingerprint);
+  if (lastSent && Date.now() - lastSent < DEDUP_COOLDOWN_MS) return true;
+  dedupMap.set(fingerprint, Date.now());
+  return false;
+}
+function sendException(tracker, props, getBreadcrumbs2) {
+  const fp = simpleFingerprint(props.type, props.stack);
+  if (isDuplicate(fp)) return;
+  tracker.track("$exception", {
+    ...props,
+    context: { breadcrumbs: getBreadcrumbs2() }
+  });
+}
+function installGlobalHandlers(tracker, getBreadcrumbs2) {
+  if (typeof window === "undefined") return;
+  window.onerror = (_message, filename, lineno, colno, error) => {
+    const err = error ?? new Error(String(_message));
+    sendException(
+      tracker,
+      {
+        type: err.name || "Error",
+        message: err.message || String(_message),
+        stack: err.stack,
+        handled: false,
+        mechanism: "onerror",
+        source: "browser",
+        filename,
+        lineno,
+        colno
+      },
+      getBreadcrumbs2
+    );
+  };
+  window.onunhandledrejection = (event) => {
+    const reason = event.reason;
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    sendException(
+      tracker,
+      {
+        type: err.name || "UnhandledRejection",
+        message: err.message,
+        stack: err.stack,
+        handled: false,
+        mechanism: "onunhandledrejection",
+        source: "browser"
+      },
+      getBreadcrumbs2
+    );
+  };
+}
+
+// src/flag-client.ts
+var DEFAULT_FLAG_POLL_INTERVAL = 6e4;
+var FlagClient = class {
+  endpoint;
+  writeKey;
+  timeout;
+  environment;
+  getIdentity;
+  onEvaluation;
+  cache = /* @__PURE__ */ new Map();
+  ready = false;
+  readyCallbacks = [];
+  changeListeners = /* @__PURE__ */ new Set();
+  evalTracked = /* @__PURE__ */ new Set();
+  timer = null;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.writeKey = config.writeKey;
+    this.timeout = config.timeout ?? 1e4;
+    this.environment = config.environment;
+    this.getIdentity = config.getIdentity;
+    this.onEvaluation = config.onEvaluation;
+    const interval = config.pollInterval ?? DEFAULT_FLAG_POLL_INTERVAL;
+    this.fetch();
+    this.timer = setInterval(() => this.fetch(), interval);
+  }
+  getFlag(key, defaultValue) {
+    const flag = this.cache.get(key);
+    if (!flag) return defaultValue;
+    if (!this.evalTracked.has(key)) {
+      this.evalTracked.add(key);
+      this.onEvaluation?.(key, flag);
+    }
+    return flag.value;
+  }
+  onFlagsReady(callback) {
+    if (this.ready) {
+      callback();
+    } else {
+      this.readyCallbacks.push(callback);
+    }
+  }
+  onFlagChange(listener) {
+    this.changeListeners.add(listener);
+    return () => this.changeListeners.delete(listener);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async fetch() {
+    if (!this.writeKey || !this.endpoint) return;
+    const params = new URLSearchParams();
+    if (this.environment) params.set("environment", this.environment);
+    const identity = this.getIdentity();
+    const identifier = identity.userId ?? identity.anonymousId;
+    if (identifier) params.set("identifier", identifier);
+    if (identity.orgId) params.set("orgId", identity.orgId);
+    const qs = params.toString();
+    const url = `${this.endpoint}/api/flags${qs ? `?${qs}` : ""}`;
+    try {
+      const res = await globalThis.fetch(url, {
+        headers: { Authorization: `Bearer ${this.writeKey}` },
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!res.ok) return;
+      const json = await res.json();
+      this.cache.clear();
+      for (const [key, flag] of Object.entries(json.flags)) {
+        this.cache.set(key, flag);
+      }
+      if (!this.ready) {
+        this.ready = true;
+        for (const cb of this.readyCallbacks) {
+          try {
+            cb();
+          } catch {
+          }
+        }
+        this.readyCallbacks = [];
+      }
+      for (const listener of this.changeListeners) {
+        try {
+          listener();
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/client.ts
+var DEFAULT_FLUSH_AT = 10;
+var DEFAULT_FLUSH_INTERVAL = 3e3;
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1e3;
+var MAX_BATCH_SIZE = 100;
+var ANON_ID_KEY = "__scoperat_anon_id";
+var SESSION_ID_KEY = "__scoperat_session_id";
+var LAST_ACTIVITY_KEY = "__scoperat_last_activity";
+var USER_ID_KEY = "__scoperat_user_id";
+var SESSION_START_EVENT = "$session_start";
+var SESSION_END_EVENT = "$session_end";
+var TICKET_SESSION_KEY = "__scoperat_ticket_session";
+function generateAnonId() {
+  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;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function getOrCreateAnonId() {
+  if (typeof window === "undefined" || typeof localStorage === "undefined") {
+    return void 0;
+  }
+  try {
+    let id = localStorage.getItem(ANON_ID_KEY);
+    if (!id) {
+      id = generateAnonId();
+      localStorage.setItem(ANON_ID_KEY, id);
+    }
+    return id;
+  } catch {
+    return generateAnonId();
+  }
+}
+var TrackerImpl = class {
+  writeKey = null;
+  endpoint = "";
+  flushAt = DEFAULT_FLUSH_AT;
+  flushInterval = DEFAULT_FLUSH_INTERVAL;
+  timeout = DEFAULT_TIMEOUT;
+  onError;
+  buffer = [];
+  timer = null;
+  visibilityHandler = null;
+  userId;
+  orgId;
+  traits = {};
+  userHash;
+  anonymousId;
+  sessionId;
+  sessionTimeout = DEFAULT_SESSION_TIMEOUT;
+  ticketSessionFetch = null;
+  _flagClient = null;
+  init(writeKey, options = {}) {
+    this.writeKey = writeKey;
+    this.endpoint = (options.endpoint ?? globalThis.location?.origin ?? "").replace(/\/+$/, "");
+    this.flushAt = options.flushAt ?? DEFAULT_FLUSH_AT;
+    this.flushInterval = options.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.onError = options.onError;
+    this.sessionTimeout = options.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
+    this.anonymousId = getOrCreateAnonId();
+    if (this.timer) clearInterval(this.timer);
+    this.timer = setInterval(() => {
+      if (this.buffer.length > 0) {
+        this.flush().catch(() => {
+        });
+      }
+    }, this.flushInterval);
+    if (typeof window !== "undefined") {
+      if (this.visibilityHandler) {
+        window.removeEventListener("visibilitychange", this.visibilityHandler);
+      }
+      this.visibilityHandler = () => {
+        if (document.visibilityState === "hidden" && this.buffer.length > 0) {
+          this.flushSync();
+        }
+      };
+      window.addEventListener("visibilitychange", this.visibilityHandler);
+    }
+    if (options.captureErrors) {
+      installGlobalHandlers(this, getBreadcrumbs);
+      startBreadcrumbCollection();
+    }
+    this._flagClient?.destroy();
+    this._flagClient = new FlagClient({
+      endpoint: this.endpoint,
+      writeKey,
+      timeout: this.timeout,
+      environment: options.environment,
+      pollInterval: options.flagPollInterval,
+      getIdentity: () => ({
+        userId: this.userId,
+        anonymousId: this.anonymousId,
+        orgId: this.orgId
+      }),
+      onEvaluation: (key, flag) => this.track("$flag_evaluation", {
+        flag_key: key,
+        flag_value: flag.value,
+        flag_type: flag.type,
+        flag_source: flag.source
+      })
+    });
+  }
+  /** The underlying flag evaluation client. Use for direct SDK integration. */
+  get flags() {
+    if (!this._flagClient) {
+      throw new Error("Tracker not initialized. Call init() first.");
+    }
+    return this._flagClient;
+  }
+  identify(userId, traits, options) {
+    const previousUserId = this.userId ?? this.readStoredUserId();
+    this.userId = userId;
+    if (traits) {
+      this.traits = { ...traits };
+      if (traits.orgId) this.orgId = traits.orgId;
+    }
+    this.userHash = options?.userHash;
+    for (const evt of this.buffer) {
+      if (!evt.user_id) evt.user_id = userId;
+      if (!evt.org_id && this.orgId) evt.org_id = this.orgId;
+    }
+    if (userId !== previousUserId) {
+      this.writeStoredUserId(userId);
+      this.startSession("login");
+    }
+    this._flagClient?.refresh();
+  }
+  reset() {
+    this.endSession("logout", true);
+    this.userId = void 0;
+    this.orgId = void 0;
+    this.traits = {};
+    this.userHash = void 0;
+    this.anonymousId = getOrCreateAnonId();
+    this.clearStoredUserId();
+    this.clearTicketSession();
+  }
+  /**
+   * Begin a new analytics session, ending the current one first if it
+   * exists. Emits `$session_end` (for the old session) and
+   * `$session_start` (for the new). Called automatically on login via
+   * {@link identify}; also exposed for explicit control.
+   */
+  startSession(reason = "login") {
+    if (typeof window === "undefined") return this.sessionId;
+    const now = Date.now();
+    const existingId = this.readStoredSession();
+    if (existingId) {
+      this.emitSessionEvent(SESSION_END_EVENT, existingId, reason);
+    }
+    const newId = generateAnonId();
+    this.persistSession(newId, now);
+    this.emitSessionEvent(SESSION_START_EVENT, newId, reason);
+    return newId;
+  }
+  /**
+   * End the current analytics session (if any), emitting `$session_end`,
+   * and clear the stored session. The next tracked event will lazily
+   * start a fresh session. Called automatically on logout via
+   * {@link reset}; also exposed for explicit control.
+   *
+   * @param immediate - flush buffered events synchronously (via
+   *   `sendBeacon`) so the end event isn't lost if the page unloads.
+   */
+  endSession(reason = "logout", immediate = false) {
+    if (typeof window === "undefined") return;
+    const existingId = this.readStoredSession();
+    if (existingId) {
+      this.emitSessionEvent(SESSION_END_EVENT, existingId, reason);
+    }
+    this.sessionId = void 0;
+    this.clearSession();
+    if (immediate) {
+      if (typeof navigator === "undefined" || !navigator.sendBeacon) {
+        this.flush().catch(() => {
+        });
+      } else {
+        this.flushSync();
+      }
+    }
+  }
+  readStoredUserId() {
+    if (typeof localStorage === "undefined") return void 0;
+    try {
+      return localStorage.getItem(USER_ID_KEY) ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  writeStoredUserId(userId) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(USER_ID_KEY, userId);
+    } catch {
+    }
+  }
+  clearStoredUserId() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.removeItem(USER_ID_KEY);
+    } catch {
+    }
+  }
+  clearTicketSession() {
+    this.ticketSessionFetch = null;
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.removeItem(TICKET_SESSION_KEY);
+    } catch {
+    }
+  }
+  readStoredTicketSession() {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(TICKET_SESSION_KEY);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.anonymousId === "string" && typeof parsed.token === "string" && typeof parsed.expiresAt === "number" && parsed.expiresAt > Date.now() + 6e4) {
+        return parsed;
+      }
+      localStorage.removeItem(TICKET_SESSION_KEY);
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * @internal Used by the widget API helpers. Returns a cached or
+   * newly-minted anonymous session token, or `null` if the server
+   * has anonymous sessions disabled. Coalesces concurrent callers
+   * onto a single in-flight network request so mount-time parallel
+   * API calls don't each trigger a `POST /ticket/session`.
+   */
+  _ensureTicketSession() {
+    const cached = this.readStoredTicketSession();
+    if (cached) return Promise.resolve(cached);
+    if (this.ticketSessionFetch) return this.ticketSessionFetch;
+    if (!this.writeKey) return Promise.resolve(null);
+    this.ticketSessionFetch = (async () => {
+      try {
+        const res = await fetch(`${this.endpoint}/api/ingest/ticket/session`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.writeKey}`
+          },
+          body: "{}",
+          signal: AbortSignal.timeout(this.timeout)
+        });
+        if (!res.ok) return null;
+        const json = await res.json();
+        if (typeof json?.anonymousId === "string" && typeof json?.token === "string" && typeof json?.expiresAt === "number") {
+          try {
+            localStorage?.setItem(TICKET_SESSION_KEY, JSON.stringify(json));
+          } catch {
+          }
+          this.anonymousId = json.anonymousId;
+          return json;
+        }
+        return null;
+      } catch {
+        return null;
+      } finally {
+        this.ticketSessionFetch = null;
+      }
+    })();
+    return this.ticketSessionFetch;
+  }
+  /**
+   * Return the id of the current session, rotating it when the previous
+   * session has expired through inactivity. On rotation it emits a
+   * `$session_end` for the timed-out session (backdated to the last
+   * recorded activity) and a `$session_start` for the new one. Called on
+   * every tracked event so sessions advance with real user activity.
+   */
+  ensureSession(now) {
+    if (typeof window === "undefined") return this.sessionId;
+    try {
+      const lastActivity = this.readLastActivity();
+      const existingId = this.readStoredSession();
+      const expired = lastActivity === void 0 || now - lastActivity > this.sessionTimeout;
+      if (existingId && !expired) {
+        this.sessionId = existingId;
+        try {
+          localStorage.setItem(LAST_ACTIVITY_KEY, String(now));
+        } catch {
+        }
+        return existingId;
+      }
+      if (existingId) {
+        this.emitSessionEvent(
+          SESSION_END_EVENT,
+          existingId,
+          "timeout",
+          lastActivity !== void 0 ? new Date(lastActivity).toISOString() : void 0
+        );
+      }
+      const newId = generateAnonId();
+      this.persistSession(newId, now);
+      this.emitSessionEvent(
+        SESSION_START_EVENT,
+        newId,
+        existingId ? "timeout" : "initial"
+      );
+      return newId;
+    } catch {
+      return this.sessionId ?? generateAnonId();
+    }
+  }
+  readStoredSession() {
+    if (this.sessionId) return this.sessionId;
+    if (typeof sessionStorage === "undefined") return void 0;
+    try {
+      return sessionStorage.getItem(SESSION_ID_KEY) ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  readLastActivity() {
+    if (typeof localStorage === "undefined") return void 0;
+    try {
+      const raw = localStorage.getItem(LAST_ACTIVITY_KEY);
+      return raw ? Number(raw) : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  persistSession(id, now) {
+    this.sessionId = id;
+    if (typeof window === "undefined") return;
+    try {
+      sessionStorage.setItem(SESSION_ID_KEY, id);
+      localStorage.setItem(LAST_ACTIVITY_KEY, String(now));
+    } catch {
+    }
+  }
+  /**
+   * Enqueue a session lifecycle event already stamped with its session id
+   * (so it never re-enters {@link ensureSession} and risks recursion).
+   */
+  emitSessionEvent(event, sessionId, reason, occurredAt) {
+    if (!this.writeKey) return;
+    const traitsContext = Object.keys(this.traits).length > 0 ? { traits: this.traits } : {};
+    this.buffer.push({
+      event,
+      properties: { reason },
+      occurred_at: occurredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      source: "browser",
+      org_id: this.orgId,
+      user_id: this.userId,
+      anonymous_id: this.anonymousId,
+      session_id: sessionId,
+      context: {
+        ...getBrowserContext(),
+        ...traitsContext
+      }
+    });
+  }
+  clearSession() {
+    if (typeof window === "undefined") return;
+    try {
+      sessionStorage.removeItem(SESSION_ID_KEY);
+      localStorage.removeItem(LAST_ACTIVITY_KEY);
+    } catch {
+    }
+  }
+  getSessionId() {
+    return this.ensureSession(Date.now());
+  }
+  /** @internal Used by the widget to read tracker config. */
+  _getEndpoint() {
+    return this.endpoint;
+  }
+  /** @internal Used by the widget to read the write key. */
+  _getWriteKey() {
+    return this.writeKey;
+  }
+  /** @internal Used by the widget to read the current user identity. */
+  _getIdentity() {
+    return {
+      userId: this.userId,
+      anonymousId: this.anonymousId,
+      email: this.traits.email,
+      name: this.traits.name,
+      userHash: this.userHash
+    };
+  }
+  captureException(error, context) {
+    if (!this.writeKey) return;
+    const breadcrumbs = getBreadcrumbs();
+    this.track("$exception", {
+      type: error.name || "Error",
+      message: error.message,
+      stack: error.stack,
+      handled: true,
+      mechanism: context?.mechanism ?? "manual",
+      source: "browser",
+      ...context,
+      context: { breadcrumbs }
+    });
+  }
+  addBreadcrumb(category, message, data) {
+    addBreadcrumb({
+      type: "custom",
+      category,
+      message,
+      timestamp: Date.now(),
+      data
+    });
+  }
+  track(eventOrName, properties) {
+    if (!this.writeKey) return;
+    const evt = typeof eventOrName === "string" ? { event: eventOrName, properties } : eventOrName;
+    const traitsContext = Object.keys(this.traits).length > 0 ? { traits: this.traits } : {};
+    const enriched = {
+      ...evt,
+      occurred_at: evt.occurred_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      source: evt.source ?? "browser",
+      org_id: evt.org_id ?? this.orgId,
+      user_id: evt.user_id ?? this.userId,
+      anonymous_id: evt.anonymous_id ?? this.anonymousId,
+      session_id: evt.session_id ?? this.ensureSession(Date.now()),
+      context: {
+        ...getBrowserContext(),
+        ...traitsContext,
+        ...evt.context
+      }
+    };
+    this.buffer.push(enriched);
+    if (this.buffer.length >= this.flushAt) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  async flush() {
+    if (!this.writeKey || this.buffer.length === 0) {
+      return { success: true, ingested: 0 };
+    }
+    const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+    try {
+      const res = await fetch(`${this.endpoint}/api/ingest/track`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.writeKey}`
+        },
+        body: JSON.stringify({ events: batch }),
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`API returned ${res.status}: ${body}`);
+      }
+      const json = await res.json();
+      return { success: true, ingested: json.ingested };
+    } catch (error) {
+      this.buffer.unshift(...batch);
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.onError?.(err, batch);
+      return { success: false, ingested: 0 };
+    }
+  }
+  flushSync() {
+    if (!this.writeKey) return;
+    if (typeof navigator === "undefined" || !navigator.sendBeacon) return;
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+    const payload = JSON.stringify({ events: batch });
+    const url = `${this.endpoint}/api/ingest/track?key=${encodeURIComponent(this.writeKey)}`;
+    try {
+      const blob = new Blob([payload], { type: "application/json" });
+      navigator.sendBeacon(url, blob);
+    } catch {
+    }
+  }
+  getFlag(key, defaultValue) {
+    return this._flagClient?.getFlag(key, defaultValue) ?? defaultValue;
+  }
+  onFlagsReady(callback) {
+    this._flagClient?.onFlagsReady(callback);
+  }
+  onFlagChange(listener) {
+    return this._flagClient?.onFlagChange(listener) ?? (() => {
+    });
+  }
+  async refreshFlags() {
+    await this._flagClient?.refresh();
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this._flagClient?.destroy();
+    this._flagClient = null;
+    if (typeof window !== "undefined" && this.visibilityHandler) {
+      window.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+    while (this.buffer.length > 0) {
+      await this.flush();
+    }
+  }
+};
+var scoperat = new TrackerImpl();
+var client_default = scoperat;
+
+// src/index.ts
+var src_default = client_default;
+export {
+  FlagClient,
+  src_default as default
+};
 //# sourceMappingURL=index.js.map