@metricinsights/ca-analytics 0.1.0

package/dist/index.cjs

@@ -0,0 +1,633 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ENTITY_NAME: () => ENTITY_NAME,
+  VERSION: () => VERSION,
+  init: () => init,
+  isActive: () => isActive,
+  shutdown: () => shutdown,
+  track: () => track,
+  trackElement: () => trackElement,
+  trackPageView: () => trackPageView,
+  useAnalytics: () => useAnalytics
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/constants.ts
+var ENTITY_NAME = "analytics_events";
+var VERSION = "0.1.0";
+var MI_PAGE_PATH_RE = /^\/(p[tl]?)\/([^/]+)(.*)$/;
+var WIDTHS = {
+  app: 100,
+  event: 100,
+  page_path: 400,
+  version: 20,
+  meta: 2e3
+};
+var RESERVED_EVENTS = ["page_view", "heartbeat", "component_render", "element_click"];
+var EVENT_NAME_RE = /^[a-z][a-z0-9_]{0,99}$/;
+var LIMITS = { referrer: 300, query: 300 };
+
+// src/core/config.ts
+var UNSUBSTITUTED_RE = /^\[[A-Za-z0-9][A-Za-z0-9 _-]*\]$/;
+function portalVariables() {
+  if (typeof window === "undefined") return {};
+  const block = window.PP_VARIABLES;
+  return block && typeof block === "object" && !Array.isArray(block) ? block : {};
+}
+function readFlag(key) {
+  const raw = portalVariables()[key];
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw !== "string") return void 0;
+  const value = raw.trim().toLowerCase();
+  if (value === "" || UNSUBSTITUTED_RE.test(raw.trim())) return void 0;
+  return value !== "0" && value !== "false" && value !== "n" && value !== "no";
+}
+function matchPage() {
+  if (typeof window === "undefined" || !window.location) return null;
+  return MI_PAGE_PATH_RE.exec(window.location.pathname);
+}
+function currentPagePath() {
+  const match = matchPage();
+  if (!match) return "/";
+  const rest = match[3];
+  return (rest && rest !== "" && rest !== "/" ? rest : "/").slice(0, WIDTHS.page_path);
+}
+function resolveConfig(options = {}) {
+  const enabled = options.enabled ?? readFlag("CUSTOM_APP_ANALYTICS_ENABLED") ?? true;
+  if (!enabled) return null;
+  const app = (options.app ?? matchPage()?.[2] ?? "").slice(0, WIDTHS.app);
+  if (!app) return null;
+  return { app, endpoint: `/data/page/${encodeURIComponent(app)}/${ENTITY_NAME}` };
+}
+
+// src/core/event.ts
+var pad2 = (n) => String(n).padStart(2, "0");
+function toId(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.trunc(n) : 0;
+}
+function formatTs(date) {
+  return `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())} ${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}:${pad2(date.getUTCSeconds())}`;
+}
+function stringify(value) {
+  try {
+    const out = JSON.stringify(value);
+    return typeof out === "string" ? out : null;
+  } catch {
+    return null;
+  }
+}
+function serializeMeta(meta) {
+  if (!meta) return "{}";
+  const full = stringify(meta);
+  if (full !== null && full.length <= WIDTHS.meta) return full;
+  const kept = {};
+  for (const [key, value] of Object.entries(meta)) {
+    const candidate = stringify({ ...kept, [key]: value, _truncated: 1 });
+    if (candidate === null || candidate.length > WIDTHS.meta) continue;
+    kept[key] = value;
+  }
+  return stringify({ ...kept, _truncated: 1 }) ?? "{}";
+}
+function uuid() {
+  const c = typeof crypto !== "undefined" ? crypto : void 0;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function createRow(input) {
+  return {
+    id: uuid(),
+    ts: formatTs(/* @__PURE__ */ new Date()),
+    app: input.app.slice(0, WIDTHS.app),
+    event: input.event.slice(0, WIDTHS.event),
+    session_id: input.sessionId.slice(0, 36),
+    page_path: input.pagePath.slice(0, WIDTHS.page_path),
+    element_id: toId(input.elementId),
+    version: VERSION.slice(0, WIDTHS.version),
+    meta: serializeMeta(input.meta)
+  };
+}
+
+// src/core/transport.ts
+var RETRY_DELAY_MS = 2e3;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var toArrayBody = (rows) => `[${rows.join(",")}]`;
+async function post(endpoint, body) {
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+    if (!response.ok) {
+      return { ok: false, retryable: response.status === 429 || response.status >= 500 };
+    }
+    const payload = await response.json().catch(() => null);
+    if (payload && typeof payload.resultCode === "number" && payload.resultCode !== 0) {
+      return { ok: false, retryable: false };
+    }
+    return { ok: true, retryable: false };
+  } catch {
+    return { ok: false, retryable: true };
+  }
+}
+async function send(endpoint, rows) {
+  if (rows.length === 0) return "ok";
+  const body = toArrayBody(rows);
+  const first = await post(endpoint, body);
+  if (first.ok) return "ok";
+  if (!first.retryable) return "failed";
+  await sleep(RETRY_DELAY_MS);
+  return (await post(endpoint, body)).ok ? "ok" : "failed";
+}
+function sendOnUnload(endpoint, rows) {
+  if (rows.length === 0) return;
+  const body = toArrayBody(rows);
+  try {
+    const blob = new Blob([body], { type: "application/json" });
+    if (navigator.sendBeacon && navigator.sendBeacon(endpoint, blob)) return;
+  } catch {
+  }
+  try {
+    void fetch(endpoint, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { "Content-Type": "application/json" },
+      body,
+      keepalive: true
+    });
+  } catch {
+  }
+}
+
+// src/core/queue.ts
+var FLUSH_INTERVAL_MS = 15e3;
+var MAX_FLUSH_ROWS = 50;
+var MAX_FLUSH_BYTES = 3e4;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var textEncoder = new TextEncoder();
+function createQueue(endpoint, onKilled) {
+  let buffer = [];
+  let bytes = 0;
+  let failures = 0;
+  let stopped = false;
+  let inFlight = false;
+  let killed = false;
+  const timer = setInterval(() => {
+    void flush();
+  }, FLUSH_INTERVAL_MS);
+  function stop() {
+    stopped = true;
+    buffer = [];
+    bytes = 0;
+    clearInterval(timer);
+  }
+  async function flush() {
+    if (stopped || inFlight || buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    bytes = 0;
+    inFlight = true;
+    try {
+      let outcome;
+      try {
+        outcome = await send(
+          endpoint,
+          batch.map((b) => b.json)
+        );
+      } catch {
+        outcome = "failed";
+      }
+      if (outcome === "ok") {
+        failures = 0;
+        return;
+      }
+      failures += 1;
+      if (failures >= MAX_CONSECUTIVE_FAILURES && !killed) {
+        killed = true;
+        stop();
+        try {
+          onKilled?.();
+        } catch {
+        }
+      }
+    } finally {
+      inFlight = false;
+    }
+  }
+  return {
+    push(row) {
+      if (stopped) return;
+      let json;
+      try {
+        json = JSON.stringify(row);
+      } catch {
+        return;
+      }
+      const size = textEncoder.encode(json).length;
+      buffer.push({ json, size });
+      bytes += size;
+      if (buffer.length >= MAX_FLUSH_ROWS || bytes >= MAX_FLUSH_BYTES) void flush();
+    },
+    flush() {
+      void flush();
+    },
+    flushOnUnload() {
+      if (stopped || buffer.length === 0) return;
+      const batch = buffer;
+      buffer = [];
+      bytes = 0;
+      sendOnUnload(
+        endpoint,
+        batch.map((b) => b.json)
+      );
+    },
+    stop
+  };
+}
+
+// src/core/session.ts
+var SID_KEY = "ca_pa_sid";
+var LAST_KEY = "ca_pa_last";
+var IDLE_MS = 30 * 60 * 1e3;
+var TOUCH_THROTTLE_MS = 5e3;
+var memoryId = null;
+var lastWrittenAt = 0;
+function read(key) {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function write(key, value) {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function newId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  } catch {
+  }
+  return `s-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function resetSession() {
+  memoryId = null;
+  lastWrittenAt = 0;
+}
+function getSessionId() {
+  const now = Date.now();
+  const storedId = read(SID_KEY);
+  const rawLast = read(LAST_KEY);
+  const last = rawLast === null ? Number.NaN : Number(rawLast);
+  const alive = Number.isFinite(last) && now - last <= IDLE_MS;
+  let id;
+  if (storedId && alive) {
+    id = storedId;
+  } else if (!storedId && memoryId) {
+    id = memoryId;
+  } else {
+    id = newId();
+    write(SID_KEY, id);
+    lastWrittenAt = 0;
+  }
+  memoryId = id;
+  if (now - lastWrittenAt >= TOUCH_THROTTLE_MS) {
+    write(LAST_KEY, String(now));
+    lastWrittenAt = now;
+  }
+  return id;
+}
+
+// src/core/signals/heartbeat.ts
+var HEARTBEAT_FAST_MS = 6e4;
+var HEARTBEAT_SLOW_MS = 3e5;
+var HEARTBEAT_FAST_COUNT = 5;
+function startHeartbeat(emit) {
+  let beats = 0;
+  let timer;
+  let stopped = false;
+  const interval = () => beats < HEARTBEAT_FAST_COUNT ? HEARTBEAT_FAST_MS : HEARTBEAT_SLOW_MS;
+  function schedule() {
+    if (stopped || timer !== void 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      if (stopped || document.visibilityState !== "visible") return;
+      beats += 1;
+      try {
+        emit();
+      } catch {
+      }
+      schedule();
+    }, interval());
+  }
+  function clear() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }
+  const onVisibilityChange = () => {
+    if (stopped) return;
+    if (document.visibilityState === "visible") {
+      schedule();
+    } else {
+      clear();
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  if (document.visibilityState === "visible") schedule();
+  return {
+    stop() {
+      stopped = true;
+      clear();
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    }
+  };
+}
+
+// src/core/signals/miRender.ts
+var RENDER_CAP = 50;
+function startMiRender(emit) {
+  let stopped = false;
+  const counts = /* @__PURE__ */ new Map();
+  const onRender = (event) => {
+    if (stopped) return;
+    try {
+      const detail = event.detail;
+      if (!detail || typeof detail !== "object") return;
+      const component = typeof detail.component === "string" ? detail.component : "";
+      if (!component) return;
+      const props = detail.props && typeof detail.props === "object" ? detail.props : {};
+      const elementId = toId(props.element ?? props.element_id ?? 0);
+      const segmentId = toId(props.segment ?? props.segment_value_id ?? 0);
+      const key = `${component}|${elementId}|${segmentId}`;
+      const seq = (counts.get(key) ?? 0) + 1;
+      if (seq > RENDER_CAP) return;
+      counts.set(key, seq);
+      const meta = {
+        component,
+        element_id: elementId,
+        segment_id: segmentId
+      };
+      if (seq === RENDER_CAP) meta.capped = 1;
+      emit({ elementId, meta });
+    } catch {
+    }
+  };
+  document.addEventListener("mi-render", onRender);
+  return {
+    stop() {
+      stopped = true;
+      document.removeEventListener("mi-render", onRender);
+      counts.clear();
+    }
+  };
+}
+
+// src/core/signals/pageview.ts
+var inboundReferrer = () => {
+  try {
+    const raw = document.referrer;
+    if (!raw) return "";
+    const url = new URL(raw);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return "";
+  }
+};
+function startPageView(emit, currentPath) {
+  let stopped = false;
+  let lastPath = null;
+  let lastLocation = null;
+  const locationKey = (path) => {
+    try {
+      return `${path}${window.location.search}`;
+    } catch {
+      return path;
+    }
+  };
+  const safeEmit = (resolvePath, dedupe) => {
+    if (stopped) return;
+    try {
+      const path = resolvePath();
+      const location = locationKey(path);
+      if (dedupe && location === lastLocation) return;
+      const referrer = lastPath === null ? inboundReferrer() : lastPath;
+      lastPath = path;
+      lastLocation = location;
+      emit(path, referrer);
+    } catch {
+    }
+  };
+  const originalPush = window.history.pushState;
+  const originalReplace = window.history.replaceState;
+  const patch = (original) => function patched(...args) {
+    const result = original.apply(this, args);
+    safeEmit(currentPath, true);
+    return result;
+  };
+  const patchedPush = patch(originalPush);
+  const patchedReplace = patch(originalReplace);
+  window.history.pushState = patchedPush;
+  window.history.replaceState = patchedReplace;
+  const onPopState = () => safeEmit(currentPath, true);
+  window.addEventListener("popstate", onPopState);
+  safeEmit(currentPath, true);
+  return {
+    stop() {
+      stopped = true;
+      lastPath = null;
+      lastLocation = null;
+      if (window.history.pushState === patchedPush) {
+        window.history.pushState = originalPush;
+      }
+      if (window.history.replaceState === patchedReplace) {
+        window.history.replaceState = originalReplace;
+      }
+      window.removeEventListener("popstate", onPopState);
+    },
+    emitNow(path) {
+      safeEmit(() => path ?? currentPath(), false);
+    }
+  };
+}
+
+// src/core/analytics.ts
+var runtime = null;
+var warnedOnce = /* @__PURE__ */ new Set();
+function guard(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
+function warnOnce(key, message) {
+  if (warnedOnce.has(key)) return;
+  warnedOnce.add(key);
+  console.warn(`[ca-analytics] ${message}`);
+}
+function pageViewMeta(referrer) {
+  const query = window.location.search.replace(/^\?/, "");
+  return { referrer: referrer.slice(0, LIMITS.referrer), query: query.slice(0, LIMITS.query) };
+}
+function stopStarted(parts, flushFirst) {
+  if (flushFirst) guard(() => parts.queue.flushOnUnload());
+  guard(() => parts.pageView?.stop());
+  guard(() => parts.stopHeartbeat?.());
+  guard(() => parts.stopMiRender?.());
+  guard(() => parts.detachUnload());
+  guard(() => parts.queue.stop());
+}
+function teardown(flushFirst) {
+  const current = runtime;
+  if (!current) return;
+  runtime = null;
+  warnedOnce.clear();
+  stopStarted(current, flushFirst);
+  resetSession();
+}
+function init(options = {}) {
+  guard(() => {
+    if (runtime) return;
+    const config = resolveConfig(options);
+    if (!config) return;
+    const queue = createQueue(config.endpoint, () => shutdown());
+    const emit = (event, extra = {}) => {
+      queue.push(
+        createRow({
+          app: config.app,
+          event,
+          sessionId: getSessionId(),
+          pagePath: extra.pagePath ?? currentPagePath(),
+          elementId: extra.elementId,
+          meta: extra.meta
+        })
+      );
+    };
+    const onUnload = () => guard(() => queue.flushOnUnload());
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") onUnload();
+    };
+    const detachUnload = () => {
+      window.removeEventListener("pagehide", onUnload);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+    let pageView;
+    let stopHeartbeat;
+    let stopMiRender;
+    try {
+      window.addEventListener("pagehide", onUnload);
+      document.addEventListener("visibilitychange", onVisibility);
+      stopHeartbeat = startHeartbeat(() => emit("heartbeat")).stop;
+      stopMiRender = startMiRender(
+        (payload) => emit("component_render", { elementId: payload.elementId, meta: payload.meta })
+      ).stop;
+      pageView = startPageView(
+        (path, referrer) => emit("page_view", { pagePath: path, meta: pageViewMeta(referrer) }),
+        currentPagePath
+      );
+    } catch (error) {
+      stopStarted({ queue, detachUnload, pageView, stopHeartbeat, stopMiRender }, false);
+      throw error;
+    }
+    runtime = { queue, emit, detachUnload, pageView, stopHeartbeat, stopMiRender };
+  });
+}
+function track(event, props) {
+  guard(() => {
+    if (!runtime) return;
+    if (!event) return;
+    const normalized = event.toLowerCase();
+    if (RESERVED_EVENTS.includes(normalized)) {
+      warnOnce("reserved", `"${event}" is reserved and was not tracked (further occurrences are silent)`);
+      return;
+    }
+    if (!EVENT_NAME_RE.test(event)) {
+      warnOnce("name", `"${event}" is not snake_case \u2264100 chars; tracked as-is (further occurrences are silent)`);
+    }
+    runtime.emit(event, { meta: props });
+  });
+}
+function trackElement(props) {
+  guard(() => {
+    if (!runtime) return;
+    const { element_id, segment_id, ...extra } = props ?? {};
+    const id = toId(element_id);
+    if (!id) {
+      warnOnce("element", `trackElement() ignored a non-finite or zero element_id (${element_id})`);
+      return;
+    }
+    const segmentRaw = Number(segment_id);
+    const segmentFinite = Number.isFinite(segmentRaw);
+    if (segment_id !== void 0 && !segmentFinite) {
+      warnOnce("segment", `trackElement() got a non-finite segment_id (${segment_id}); recorded as 0`);
+    }
+    const meta = {
+      ...extra,
+      element_id: id,
+      segment_id: segmentFinite ? Math.trunc(segmentRaw) : 0
+    };
+    runtime.emit("element_click", { elementId: id, meta });
+  });
+}
+function trackPageView(path) {
+  guard(() => runtime?.pageView.emitNow(path));
+}
+function shutdown() {
+  guard(() => teardown(true));
+}
+function isActive() {
+  return runtime !== null;
+}
+
+// src/react/useAnalytics.ts
+var api = { track, trackElement, trackPageView };
+function useAnalytics() {
+  return api;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTITY_NAME,
+  VERSION,
+  init,
+  isActive,
+  shutdown,
+  track,
+  trackElement,
+  trackPageView,
+  useAnalytics
+});
+//# sourceMappingURL=index.cjs.map