@corbado/observe 1.9.0 → 1.9.1

package/dist/analysis/config-manager.mjs

@@ -1,36 +1,139 @@
 // src/config-manager.ts
-import { cacheConfig, loadCachedConfig, parseReliabilityConfig } from "./config.mjs";
+import {
+  cacheConfigRecord,
+  CONFIG_STORAGE_KEY,
+  loadCachedConfig,
+  loadConfigRecord,
+  parseReliabilityConfig
+} from "./config.mjs";
 import { sendFetch } from "./readers/network.mjs";
+import { listenWindow, readDocumentHidden } from "./readers/page.mjs";
 var CONFIG_FETCH_TIMEOUT_MS = 10 * 1e3;
-var CONFIG_REFRESH_INTERVAL_MS = 10 * 60 * 1e3;
+var CONFIG_MIN_ATTEMPT_GAP_MS = 60 * 1e3;
+var CONFIG_DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var CONFIG_MIN_TTL_MS = 5 * 60 * 1e3;
+var CONFIG_MAX_TTL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_RETRY_DELAYS_MS = [1e3, 3e3];
+function configTtlMs(headers) {
+  const maxAge = /(?:^|[\s,])max-age\s*=\s*"?(\d+)"?/i.exec(headers?.get("Cache-Control") ?? "");
+  if (!maxAge) return CONFIG_DEFAULT_TTL_MS;
+  const age = Number(headers?.get("Age") ?? 0);
+  const ttlMs = (Number(maxAge[1]) - (Number.isFinite(age) && age > 0 ? age : 0)) * 1e3;
+  return Math.min(Math.max(ttlMs, CONFIG_MIN_TTL_MS), CONFIG_MAX_TTL_MS);
+}
 var ConfigManager = class {
   constructor(url, storage, logger) {
     this.url = url;
     this.storage = storage;
     this.logger = logger;
     this.initialConfig = loadCachedConfig(storage) ?? void 0;
+    this.appliedVersion = this.initialConfig?.version;
   }
   initialConfig;
-  refreshTimer;
   requestTimer;
   retryTimer;
   controller;
+  removers = [];
   fetching = false;
   stopped = false;
+  lastAttemptAt;
+  /** Version last handed to (or initially applied by) the tracker. */
+  appliedVersion;
   onConfig;
   start(onConfig) {
     if (this.stopped || this.onConfig) return;
     this.onConfig = onConfig;
-    void this.fetchConfig();
+    this.listen();
+    this.refresh();
   }
-  async fetchConfig(attempt = 0) {
-    if (this.stopped || this.fetching) return;
-    if (attempt === 0) {
-      clearTimeout(this.refreshTimer);
+  listen() {
+    if (typeof window === "undefined") return;
+    const onVisibilityChange = () => {
+      const hidden = typeof document === "undefined" || readDocumentHidden({
+        key: "page:lifecycle.visibility",
+        title: "Page visibility",
+        accessNote: "document.visibilityState",
+        group: "Page lifecycle",
+        origin: "observe-external",
+        fields: [
+          {
+            path: "visibilityState",
+            label: "Whether the page is hidden",
+            exposure: "enum",
+            transform: { values: ["hidden", "other"] }
+          }
+        ]
+      });
+      if (!hidden) this.refresh();
+    };
+    this.removers.push(
+      listenWindow(
+        {
+          key: "page:lifecycle.visibilitychange",
+          title: "Page visibility changes",
+          accessNote: "visibilitychange event on document",
+          group: "Page lifecycle",
+          origin: "observe-external",
+          fields: [
+            {
+              path: "event.visibilitychange",
+              label: "Page hidden or shown again",
+              exposure: "presence",
+              transform: { note: "checks whether Observe settings are due for a refresh when the page is shown" }
+            }
+          ]
+        },
+        "visibilitychange",
+        onVisibilityChange
+      ),
+      listenWindow(
+        {
+          key: "page:lifecycle.pageshow",
+          title: "Returning to the page",
+          accessNote: "pageshow event on window, its persisted flag",
+          group: "Page lifecycle",
+          origin: "observe-external",
+          fields: [
+            {
+              path: "event.persisted",
+              label: "Page restored from the browser's back/forward cache",
+              exposure: "presence",
+              transform: { note: "checks whether Observe settings are due for a refresh" }
+            }
+          ]
+        },
+        "pageshow",
+        (event) => {
+          if (event.persisted) this.refresh();
+        }
+      )
+    );
+  }
+  /** Fetches when the cached config is stale; adopts a fresh config another tab stored meanwhile. */
+  refresh() {
+    try {
+      if (this.stopped || this.fetching) return;
+      const now = Date.now();
+      const record = loadConfigRecord(this.storage);
+      const { fetchedAt, expiresAt } = record ?? {};
+      if (record?.endpoint === this.url && typeof fetchedAt === "number" && typeof expiresAt === "number" && fetchedAt > 0 && expiresAt - fetchedAt <= CONFIG_MAX_TTL_MS && fetchedAt <= now && now < expiresAt) {
+        if (record.config.version !== this.appliedVersion) {
+          this.appliedVersion = record.config.version;
+          this.onConfig?.(record.config);
+        }
+        return;
+      }
+      const sinceAttempt = this.lastAttemptAt === void 0 ? Infinity : now - this.lastAttemptAt;
+      if (sinceAttempt >= 0 && sinceAttempt < CONFIG_MIN_ATTEMPT_GAP_MS) return;
+      this.lastAttemptAt = now;
       clearTimeout(this.retryTimer);
-      this.refreshTimer = setTimeout(() => void this.fetchConfig(), CONFIG_REFRESH_INTERVAL_MS);
+      void this.fetchConfig();
+    } catch (error) {
+      this.logger.error("Unexpected error in SDK config refresh", error);
     }
+  }
+  async fetchConfig(attempt = 0) {
+    if (this.stopped || this.fetching) return;
     this.fetching = true;
     const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
     this.controller = controller;
@@ -51,6 +154,18 @@ var ConfigManager = class {
               label: "Whether the server asked to retry later",
               exposure: "presence"
             },
+            {
+              path: "response.header.cache-control",
+              label: "How long the server allows reusing the settings",
+              exposure: "computed",
+              transform: { note: "max-age, reduced to the settings' expiry time" }
+            },
+            {
+              path: "response.header.age",
+              label: "How long the settings were already stored on the way",
+              exposure: "computed",
+              transform: { note: "subtracted from max-age for the settings' expiry time" }
+            },
             {
               path: "response.body",
               label: "Observe settings",
@@ -62,7 +177,9 @@ var ConfigManager = class {
         this.url,
         {
           method: "GET",
-          cache: "no-store",
+          // Revalidates the browser's HTTP cache entry (If-None-Match once the server sends an ETag)
+          // without a custom header, which would add a CORS preflight.
+          cache: "no-cache",
           ...controller ? { signal: controller.signal } : {}
         }
       );
@@ -75,7 +192,15 @@ var ConfigManager = class {
       const config = parseReliabilityConfig(raw);
       if (!config) throw new Error("Invalid SDK config response");
       if (this.stopped || controller?.signal.aborted) return;
-      cacheConfig(this.storage, config);
+      const now = Date.now();
+      cacheConfigRecord(this.storage, {
+        endpoint: this.url,
+        fetchedAt: now,
+        expiresAt: now + configTtlMs(response.headers),
+        config
+      });
+      if (loadConfigRecord(this.storage)) this.storage.removeItem(CONFIG_STORAGE_KEY);
+      this.appliedVersion = config.version;
       this.onConfig?.(config);
     } catch (error) {
       if (!this.stopped) {
@@ -94,7 +219,7 @@ var ConfigManager = class {
   }
   destroy() {
     this.stopped = true;
-    clearTimeout(this.refreshTimer);
+    this.removers.splice(0).forEach((remove) => remove());
     clearTimeout(this.requestTimer);
     clearTimeout(this.retryTimer);
     this.controller?.abort();
@@ -102,7 +227,11 @@ var ConfigManager = class {
   }
 };
 export {
+  CONFIG_DEFAULT_TTL_MS,
   CONFIG_FETCH_TIMEOUT_MS,
-  CONFIG_REFRESH_INTERVAL_MS,
-  ConfigManager
+  CONFIG_MAX_TTL_MS,
+  CONFIG_MIN_ATTEMPT_GAP_MS,
+  CONFIG_MIN_TTL_MS,
+  ConfigManager,
+  configTtlMs
 };

package/dist/analysis/config.mjs

@@ -1,5 +1,6 @@
 // src/config.ts
 var CONFIG_STORAGE_KEY = "cbo_sdk_config";
+var CONFIG_CACHE_STORAGE_KEY = "cbo_sdk_config_cache";
 var CONFIG_REQUEST_HEADER = "X-Corbado-Observe-Config";
 var DEFAULT_FLUSH_INTERVAL_MS = 500;
 var DEFAULT_SEQ_LOCK_TIMEOUT_MS = 50;
@@ -193,14 +194,20 @@ function resolveFixedDataConfig(raw) {
     return void 0;
   }
 }
+function loadConfigRecord(storage) {
+  const record = storage.getItem(CONFIG_CACHE_STORAGE_KEY);
+  const config = record && typeof record === "object" ? parseReliabilityConfig(record.config) : null;
+  return config ? { ...record, config } : null;
+}
 function loadCachedConfig(storage) {
-  return parseReliabilityConfig(storage.getItem(CONFIG_STORAGE_KEY));
+  return loadConfigRecord(storage)?.config ?? parseReliabilityConfig(storage.getItem(CONFIG_STORAGE_KEY));
 }
-function cacheConfig(storage, config) {
-  storage.setItem(CONFIG_STORAGE_KEY, config);
+function cacheConfigRecord(storage, record) {
+  storage.setItem(CONFIG_CACHE_STORAGE_KEY, record);
 }
 export {
   CONFIG_BOUNDS,
+  CONFIG_CACHE_STORAGE_KEY,
   CONFIG_REQUEST_HEADER,
   CONFIG_STORAGE_KEY,
   DEFAULT_DEVICE_INFO_COLLECTOR_TIMEOUT_MS,
@@ -208,8 +215,9 @@ export {
   DEFAULT_RELIABILITY_CONFIG,
   DEFAULT_SEQ_LOCK_TIMEOUT_MS,
   DEFAULT_SESSION_INACTIVITY_MS,
-  cacheConfig,
+  cacheConfigRecord,
   loadCachedConfig,
+  loadConfigRecord,
   parseReliabilityConfig,
   resolveFixedDataConfig,
   resolveReliabilityConfig

package/dist/analysis/version.mjs

@@ -1,6 +1,6 @@
 // src/version.ts
 var SDK_NAME = "@corbado/observe";
-var SDK_VERSION = true ? "1.9.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "1.9.1" : "0.0.0-dev";
 export {
   SDK_NAME,
   SDK_VERSION