@drivemetadata-ai/sdk 0.1.1-beta.4 → 0.1.1

package/dist/react/index.js

@@ -227,6 +227,15 @@ var sensitiveKeys = /* @__PURE__ */ new Set([
   "session",
   "cookie"
 ]);
+function redactUrl(url, allowQueryKeys = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"]) {
+  const parsed = new URL(url, "https://placeholder.local");
+  for (const key of Array.from(parsed.searchParams.keys())) {
+    if (!allowQueryKeys.includes(key)) {
+      parsed.searchParams.set(key, "[REDACTED]");
+    }
+  }
+  return url.startsWith("http") ? parsed.toString() : `${parsed.pathname}${parsed.search}`;
+}
 function sanitizeValue(value, allow, path = []) {
   if (Array.isArray(value)) {
     return value.map((item) => sanitizeValue(item, allow, path));
@@ -248,6 +257,127 @@ function sanitizeProperties(input, allowRawKeys = []) {
   return sanitizeValue(input, allow);
 }
 
+// src/browser/core/attribute-persistence.ts
+var DMD_ATTRIBUTES_STORAGE_KEY = "dmd_attributes";
+var SESSION_STORAGE_KEY = "sessionData";
+var SESSION_ID_KEY = "sessionId";
+var SESSION_TIMESTAMP_KEY = "timestamp";
+function isBlankValue(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function readAttributes(base) {
+  const raw = base.getItem(DMD_ATTRIBUTES_STORAGE_KEY);
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    base.removeItem(DMD_ATTRIBUTES_STORAGE_KEY);
+    return {};
+  }
+}
+function sanitizeAttributes(attributes) {
+  return Object.fromEntries(Object.entries(attributes).filter(([, value]) => !isBlankValue(value)));
+}
+function writeAttributes(base, attributes) {
+  const sanitized = sanitizeAttributes(attributes);
+  if (Object.keys(sanitized).length === 0) {
+    base.removeItem(DMD_ATTRIBUTES_STORAGE_KEY);
+    return;
+  }
+  base.setItem(DMD_ATTRIBUTES_STORAGE_KEY, JSON.stringify(sanitized));
+}
+function parseSessionData(value) {
+  try {
+    const parsed = JSON.parse(value);
+    const sessionData = {};
+    const sessionId = typeof parsed.sessionId === "string" && parsed.sessionId.trim() !== "" ? parsed.sessionId : void 0;
+    const timestamp = typeof parsed.timestamp === "number" ? parsed.timestamp : void 0;
+    if (sessionId !== void 0) sessionData.sessionId = sessionId;
+    if (timestamp !== void 0) sessionData.timestamp = timestamp;
+    return sessionData;
+  } catch {
+    return {};
+  }
+}
+function getAggregateValue(attributes, key) {
+  if (key === SESSION_STORAGE_KEY) {
+    const sessionId = attributes[SESSION_ID_KEY];
+    const timestamp = attributes[SESSION_TIMESTAMP_KEY];
+    if (typeof sessionId === "string" && !isBlankValue(sessionId) && typeof timestamp === "number") {
+      return JSON.stringify({ sessionId, timestamp });
+    }
+    return null;
+  }
+  const value = attributes[key];
+  if (isBlankValue(value)) return null;
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function setAggregateValue(attributes, key, value) {
+  if (key === SESSION_STORAGE_KEY) {
+    const sessionData = parseSessionData(value);
+    if (sessionData.sessionId === void 0 || sessionData.timestamp === void 0) {
+      delete attributes[SESSION_ID_KEY];
+      delete attributes[SESSION_TIMESTAMP_KEY];
+      return;
+    }
+    attributes[SESSION_ID_KEY] = sessionData.sessionId;
+    attributes[SESSION_TIMESTAMP_KEY] = sessionData.timestamp;
+    return;
+  }
+  attributes[key] = value;
+}
+function removeAggregateValue(attributes, key) {
+  if (key === SESSION_STORAGE_KEY) {
+    delete attributes[SESSION_ID_KEY];
+    delete attributes[SESSION_TIMESTAMP_KEY];
+    return;
+  }
+  delete attributes[key];
+}
+function createDmdAttributesPersistence(base) {
+  return {
+    getItem(key) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) return base.getItem(key);
+      const attributes = readAttributes(base);
+      const aggregateValue = getAggregateValue(attributes, key);
+      if (aggregateValue !== null) return aggregateValue;
+      const legacyValue = base.getItem(key);
+      if (isBlankValue(legacyValue)) return null;
+      setAggregateValue(attributes, key, String(legacyValue));
+      writeAttributes(base, attributes);
+      return legacyValue;
+    },
+    setItem(key, value) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) return base.setItem(key, value);
+      const attributes = readAttributes(base);
+      if (isBlankValue(value)) {
+        removeAggregateValue(attributes, key);
+        writeAttributes(base, attributes);
+        base.removeItem(key);
+        return true;
+      }
+      setAggregateValue(attributes, key, value);
+      writeAttributes(base, attributes);
+      base.setItem(key, value);
+      return true;
+    },
+    removeItem(key) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) {
+        base.removeItem(key);
+        return;
+      }
+      const attributes = readAttributes(base);
+      removeAggregateValue(attributes, key);
+      writeAttributes(base, attributes);
+      base.removeItem(key);
+    },
+    getHealth() {
+      return base.getHealth();
+    }
+  };
+}
+
 // src/core/attribution.ts
 var dmdUtmKeys = [
   "utm_source",
@@ -284,6 +414,10 @@ function mergeAttributionRecords(explicitProperties, stored) {
 }
 
 // src/browser/core/attribution.ts
+var DMD_CLICK_ID_QUERY_KEY = "click_id";
+var DMD_CLICK_ID_LEGACY_QUERY_KEY = "dmd_click_id";
+var DMD_CLICK_ID_STORAGE_KEY = "dmd_click_id";
+var DMD_CLICK_ID_ATTRIBUTE_KEY = "click_id";
 function getCurrentUrl() {
   return getBrowserWindow()?.location?.href;
 }
@@ -302,6 +436,9 @@ function setIfPresent(persistence, key, value) {
     persistence.setItem(key, value);
   }
 }
+function getClickIdParam(params) {
+  return params.get(DMD_CLICK_ID_LEGACY_QUERY_KEY) || params.get(DMD_CLICK_ID_QUERY_KEY);
+}
 function getStoredString(persistence, key) {
   const value = persistence.getItem(key);
   return value === null || value === "" ? void 0 : value;
@@ -321,6 +458,9 @@ function captureAttributionFromUrl(persistence, url = getCurrentUrl()) {
   for (const key of dmdCampaignKeys) {
     setIfPresent(persistence, key, params.get(key));
   }
+  const clickId = getClickIdParam(params);
+  setIfPresent(persistence, DMD_CLICK_ID_ATTRIBUTE_KEY, clickId);
+  setIfPresent(persistence, DMD_CLICK_ID_STORAGE_KEY, clickId);
   for (const [param, sdkPubId] of dmdClickIdSources) {
     const value = params.get(param);
     if (value) {
@@ -336,7 +476,8 @@ function getStoredAttributionData(persistence) {
     fbc: getStoredString(persistence, "fbc") ?? getCookie("_fbc"),
     fbp: getStoredString(persistence, "fbp") ?? getCookie("_fbp"),
     campaign_id: getStoredString(persistence, "campaign_id"),
-    ad_id: getStoredString(persistence, "ad_id")
+    ad_id: getStoredString(persistence, "ad_id"),
+    click_id: getStoredString(persistence, DMD_CLICK_ID_STORAGE_KEY) ?? getStoredString(persistence, DMD_CLICK_ID_ATTRIBUTE_KEY)
   });
 }
 function getStoredUtmParameter(persistence) {
@@ -855,6 +996,24 @@ function resetAnonymousId(persistence) {
   return anonymousId;
 }
 
+// src/browser/core/page-context.ts
+function redactSearch(search) {
+  const redacted = redactUrl(search);
+  return redacted.startsWith("/?") ? redacted.slice(1) : redacted;
+}
+function getBrowserPageContext() {
+  const browserWindow = getBrowserWindow();
+  const documentRef = browserWindow?.document ?? globalThis.document;
+  const location = browserWindow?.location;
+  const page2 = {};
+  if (location?.href) page2.url = location.href;
+  if (location?.pathname) page2.path = location.pathname;
+  if (location?.search) page2.search = redactSearch(location.search);
+  if (documentRef?.title) page2.title = documentRef.title;
+  if (documentRef?.referrer) page2.referrer = redactUrl(documentRef.referrer);
+  return page2;
+}
+
 // src/browser/core/persistence.ts
 function createPersistenceHealth(requested) {
   return {
@@ -1021,7 +1180,7 @@ function createBrowserPersistence(mode = "localStorage+cookie") {
 }
 
 // src/browser/core/session.ts
-var SESSION_STORAGE_KEY = "sessionData";
+var SESSION_STORAGE_KEY2 = "sessionData";
 function getUrlParam2(name) {
   const href = getBrowserWindow()?.location?.href;
   if (!href) return null;
@@ -1032,7 +1191,7 @@ function getUrlParam2(name) {
   }
 }
 function readStoredSession(persistence) {
-  const rawSession = persistence.getItem(SESSION_STORAGE_KEY);
+  const rawSession = persistence.getItem(SESSION_STORAGE_KEY2);
   if (!rawSession) return void 0;
   try {
     const parsed = JSON.parse(rawSession);
@@ -1043,12 +1202,12 @@ function readStoredSession(persistence) {
       };
     }
   } catch {
-    persistence.removeItem(SESSION_STORAGE_KEY);
+    persistence.removeItem(SESSION_STORAGE_KEY2);
   }
   return void 0;
 }
 function writeStoredSession(persistence, sessionId, timestamp) {
-  persistence.setItem(SESSION_STORAGE_KEY, JSON.stringify({ sessionId, timestamp }));
+  persistence.setItem(SESSION_STORAGE_KEY2, JSON.stringify({ sessionId, timestamp }));
 }
 function createSessionManager(persistence, idleTimeoutSeconds = 30 * 60) {
   function resolveSessionId() {
@@ -1102,11 +1261,12 @@ var DriveMetaDataSDK = class {
     requireConfigString(config.writeKey || config.token, "writeKey or token");
     this.config = config;
     this.endpoint = endpointFromConfig(config);
-    this.persistence = createBrowserPersistence(config.persistence);
+    const storagePersistence = createBrowserPersistence(config.persistence);
+    this.persistence = createDmdAttributesPersistence(storagePersistence);
     this.session = createSessionManager(this.persistence, config.sessionIdleTimeoutSeconds);
     const deliveryConfig = {
       endpoint: this.endpoint,
-      storage: this.persistence
+      storage: storagePersistence
     };
     if (config.delivery?.maxQueueSize !== void 0) deliveryConfig.maxQueueSize = config.delivery.maxQueueSize;
     if (config.delivery?.queueTtlMs !== void 0) deliveryConfig.queueTtlMs = config.delivery.queueTtlMs;
@@ -1351,6 +1511,7 @@ var DriveMetaDataSDK = class {
   }
   toCollectorPayload(prepared) {
     const browserWindow = getBrowserWindow();
+    const pageContext = getBrowserPageContext();
     return createBackendCollectorPayload({
       requestId: prepared.messageId,
       timestamp: prepared.timestamp,
@@ -1362,9 +1523,13 @@ var DriveMetaDataSDK = class {
       sessionId: prepared.sessionId,
       ua: browserWindow?.navigator?.userAgent,
       appId: prepared.appId,
-      pageUrl: browserWindow?.location?.href,
+      pageUrl: pageContext.url ?? browserWindow?.location?.href,
       eventData: mergeStoredAttribution({
         ...prepared.properties,
+        page: {
+          ...pageContext,
+          ...prepared.properties.page && typeof prepared.properties.page === "object" ? prepared.properties.page : {}
+        },
         anonymousId: prepared.anonymousId,
         sessionId: prepared.sessionId,
         timestamp: prepared.timestamp,