@tamsensedev/dataclient 0.1.0

package/dist/index.cjs

@@ -0,0 +1,979 @@
+"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, {
+  DataClient: () => DataClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var MASK_ATTR = "dataclient-mask";
+var MASK_SELECTOR = `[${MASK_ATTR}]`;
+var SKIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "svg", "link", "meta", "head"]);
+var RECORD_ATTRS = /* @__PURE__ */ new Set([
+  "class",
+  "role",
+  "href",
+  "type",
+  "placeholder",
+  "disabled",
+  "hidden",
+  "aria-label",
+  "aria-selected",
+  "aria-expanded",
+  "aria-invalid",
+  "aria-busy",
+  "aria-checked",
+  "aria-hidden",
+  "value",
+  "name",
+  "id",
+  "for",
+  "target",
+  "data-state",
+  MASK_ATTR
+]);
+var WATCH_ATTRS = [
+  "class",
+  "role",
+  "href",
+  "disabled",
+  "hidden",
+  "placeholder",
+  "aria-label",
+  "aria-selected",
+  "aria-expanded",
+  "aria-invalid",
+  "aria-busy",
+  "aria-checked",
+  "aria-hidden",
+  "data-state",
+  "value"
+];
+var TEXT_INPUT_TYPES = /* @__PURE__ */ new Set(["text", "email", "password", "search", "tel", "url", "number"]);
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["button", "a", "input", "select", "textarea"]);
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set(["button", "link", "tab", "menuitem", "checkbox", "radio", "switch", "option"]);
+
+// src/dom/mask.ts
+function isMasked(el) {
+  if (!el)
+    return false;
+  const element = el.nodeType === Node.ELEMENT_NODE ? el : el.parentElement;
+  return !!element?.closest(MASK_SELECTOR);
+}
+function maskText(text) {
+  if (!text) {
+    return text;
+  }
+  const visible = Math.max(1, Math.ceil(text.length * 0.2));
+  return text.slice(0, visible) + "*".repeat(text.length - visible);
+}
+
+// src/dom/icon.ts
+var ICON_CLASS_PATTERNS = [
+  /\bfa-([a-z0-9-]+)\b/,
+  /\bmdi-([a-z0-9-]+)\b/,
+  /\bbi-([a-z0-9-]+)\b/,
+  /\bicon-([a-z0-9-]+)\b/,
+  /\blucide-([a-z0-9-]+)\b/,
+  /\bri-([a-z0-9-]+)\b/,
+  /\btabler-icon-([a-z0-9-]+)\b/,
+  /\bi-[a-z0-9-]+[:/]([a-z0-9-]+)\b/
+];
+var MATERIAL_CLASS_PATTERN = /\b(?:material-icons|material-symbols-[a-z]+)\b/;
+var SVG_USE_HREF_PATTERN = /#(.+)/;
+var MAX_ICON_IMG_SIZE = 48;
+function getElementIcon(el) {
+  if (!el) {
+    return null;
+  }
+  const direct = detectIcon(el);
+  if (direct) {
+    return direct;
+  }
+  for (const child of el.children) {
+    const icon = detectIcon(child);
+    if (icon) {
+      return icon;
+    }
+  }
+  return null;
+}
+function detectIcon(el) {
+  if (!el?.tagName) {
+    return null;
+  }
+  const tag = el.tagName.toLowerCase();
+  if (tag === "svg") {
+    return detectSvgIcon(el);
+  }
+  if (tag === "i" || tag === "span" || el.classList.contains("iconify")) {
+    return detectFontIcon(el);
+  }
+  if (tag === "img") {
+    return detectImgIcon(el);
+  }
+  const svg = el.querySelector("svg");
+  if (svg) {
+    return detectSvgIcon(svg);
+  }
+  return null;
+}
+function detectSvgIcon(svg) {
+  const lucide = svg.getAttribute("data-lucide");
+  if (lucide) {
+    return lucide;
+  }
+  const dataIcon = svg.getAttribute("data-icon");
+  if (dataIcon) {
+    return dataIcon;
+  }
+  const use = svg.querySelector("use");
+  if (use) {
+    const href = use.getAttribute("href") || use.getAttribute("xlink:href");
+    if (href) {
+      const match = href.match(SVG_USE_HREF_PATTERN);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  const ariaLabel = svg.getAttribute("aria-label");
+  if (ariaLabel) {
+    return ariaLabel;
+  }
+  const cls = typeof svg.className === "string" ? svg.className : svg.getAttribute("class") || "";
+  const fromClass = extractIconNameFromClass(cls);
+  if (fromClass) {
+    return fromClass;
+  }
+  return null;
+}
+function detectFontIcon(el) {
+  const cls = typeof el.className === "string" ? el.className : el.getAttribute("class") || "";
+  if (MATERIAL_CLASS_PATTERN.test(cls)) {
+    const text = el.textContent?.trim();
+    if (text) {
+      return text;
+    }
+  }
+  return extractIconNameFromClass(cls);
+}
+function detectImgIcon(img) {
+  if (img.width > MAX_ICON_IMG_SIZE || img.height > MAX_ICON_IMG_SIZE) {
+    return null;
+  }
+  if (img.naturalWidth > MAX_ICON_IMG_SIZE || img.naturalHeight > MAX_ICON_IMG_SIZE) {
+    return null;
+  }
+  const alt = img.alt?.trim();
+  if (alt) {
+    return alt;
+  }
+  const src = img.getAttribute("src");
+  if (src) {
+    const filename = src.split("/").pop()?.split("?")[0]?.split(".")[0];
+    if (filename) {
+      return filename;
+    }
+  }
+  return null;
+}
+function extractIconNameFromClass(cls) {
+  for (const pattern of ICON_CLASS_PATTERNS) {
+    const match = cls.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+// src/dom/serializer.ts
+var nextId = 1;
+var nodeToId = /* @__PURE__ */ new WeakMap();
+var idToNode = /* @__PURE__ */ new Map();
+function resetIds() {
+  nextId = 1;
+  idToNode.clear();
+}
+function assignId(node) {
+  const existing = nodeToId.get(node);
+  if (existing) {
+    return existing;
+  }
+  const id = nextId++;
+  nodeToId.set(node, id);
+  idToNode.set(id, node);
+  return id;
+}
+function getNodeId(node) {
+  return nodeToId.get(node) ?? null;
+}
+function removeNodeId(id) {
+  const node = idToNode.get(id);
+  if (node) {
+    nodeToId.delete(node);
+    idToNode.delete(id);
+  }
+}
+function isVisible(el) {
+  if (el.hidden)
+    return false;
+  if (el.getAttribute("aria-hidden") === "true")
+    return false;
+  if (!el.offsetParent && el.tagName !== "BODY" && getComputedStyle(el).position !== "fixed") {
+    return false;
+  }
+  return true;
+}
+function getDirectText(el) {
+  let text = "";
+  for (const child of el.childNodes) {
+    if (child.nodeType === Node.TEXT_NODE) {
+      const t = child.textContent?.trim();
+      if (t) {
+        text += (text ? " " : "") + t;
+      }
+    }
+  }
+  const truncated = text.slice(0, 200);
+  return isMasked(el) ? maskText(truncated) : truncated;
+}
+function getAttrs(el) {
+  const attrs = {};
+  let hasAttrs = false;
+  const masked = isMasked(el);
+  for (const name of RECORD_ATTRS) {
+    const value = el.getAttribute(name);
+    if (value !== null && value !== "") {
+      let v = value.slice(0, 200);
+      if (masked && (name === "value" || name === "placeholder")) {
+        v = maskText(v);
+      }
+      attrs[name] = v;
+      hasAttrs = true;
+    }
+  }
+  return hasAttrs ? attrs : void 0;
+}
+function getRect(el) {
+  const r = el.getBoundingClientRect();
+  if (r.width === 0 && r.height === 0) {
+    return void 0;
+  }
+  return {
+    x: Math.round(r.left + window.scrollX),
+    y: Math.round(r.top + window.scrollY),
+    w: Math.round(r.width),
+    h: Math.round(r.height)
+  };
+}
+function serializeNode(el) {
+  const tag = el.tagName?.toLowerCase();
+  if (!tag || SKIP_TAGS.has(tag)) {
+    return null;
+  }
+  if (!isVisible(el)) {
+    return null;
+  }
+  const id = assignId(el);
+  const text = getDirectText(el);
+  const icon = getElementIcon(el);
+  const attrs = getAttrs(el);
+  const rect = getRect(el);
+  const children = [];
+  for (const child of el.children) {
+    const serialized = serializeNode(child);
+    if (serialized) {
+      children.push(serialized.id);
+    }
+  }
+  const node = { id, tag };
+  if (text) {
+    node.text = text;
+  }
+  if (icon) {
+    node.icon = icon;
+  }
+  if (attrs) {
+    node.attrs = attrs;
+  }
+  if (rect) {
+    node.rect = rect;
+  }
+  if (children.length > 0) {
+    node.children = children;
+  }
+  return node;
+}
+function serializeTree(root) {
+  const nodes = [];
+  function walk(el) {
+    const node = serializeNode(el);
+    if (!node) {
+      return;
+    }
+    nodes.push(node);
+    for (const child of el.children) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return nodes;
+}
+
+// src/dom/viewport.ts
+function getViewport() {
+  return {
+    scrollX: Math.round(window.scrollX),
+    scrollY: Math.round(window.scrollY),
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+}
+
+// src/trackers/rrweb.ts
+var import_rrweb = require("rrweb");
+var RrwebTracker = class {
+  constructor(config, sender) {
+    this.config = config;
+    this.sender = sender;
+  }
+  config;
+  sender;
+  stopFn = null;
+  start() {
+    this.stopFn = (0, import_rrweb.record)({
+      emit: (event) => {
+        const rrwebEvent = {
+          event: "rrweb",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          rrwebEvent: event
+        };
+        this.sender.add(rrwebEvent);
+      },
+      recordCrossOriginIframes: false,
+      recordCanvas: false,
+      maskTextSelector: MASK_SELECTOR,
+      maskInputOptions: { password: true },
+      maskTextFn: (text) => "*".repeat(text.length),
+      sampling: {
+        mousemove: false,
+        mouseInteraction: true,
+        scroll: 500,
+        input: "last"
+      }
+    }) ?? null;
+    if (this.config.debug)
+      console.log("[dataclient] rrweb recording started");
+  }
+  stop() {
+    if (this.stopFn) {
+      this.stopFn();
+      this.stopFn = null;
+    }
+  }
+  static addMarker(tag, payload) {
+    import_rrweb.record.addCustomEvent(tag, payload);
+  }
+};
+
+// src/trackers/action.ts
+var ActionTracker = class {
+  constructor(config, sender) {
+    this.config = config;
+    this.sender = sender;
+  }
+  config;
+  sender;
+  inputTimers = /* @__PURE__ */ new WeakMap();
+  pendingInputs = /* @__PURE__ */ new Set();
+  handleClick = (e) => this.onClick(e);
+  handleInput = (e) => this.onInput(e);
+  handleChange = (e) => this.onChange(e);
+  start() {
+    document.addEventListener("click", this.handleClick, true);
+    document.addEventListener("input", this.handleInput, true);
+    document.addEventListener("change", this.handleChange, true);
+  }
+  stop() {
+    document.removeEventListener("click", this.handleClick, true);
+    document.removeEventListener("input", this.handleInput, true);
+    document.removeEventListener("change", this.handleChange, true);
+  }
+  beforeUnload() {
+    for (const el of this.pendingInputs) {
+      const timer = this.inputTimers.get(el);
+      if (timer) {
+        clearTimeout(timer);
+      }
+      this.inputTimers.delete(el);
+      this.recordInput(el);
+    }
+    this.pendingInputs.clear();
+  }
+  onClick(e) {
+    const raw = e.target;
+    if (!raw) {
+      return;
+    }
+    const tag = raw.tagName?.toLowerCase();
+    if (tag === "body" || tag === "html") {
+      return;
+    }
+    const el = this.findMeaningfulElement(raw);
+    const info = this.getElementInfo(el);
+    const action = {
+      event: "action",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "click",
+      targetId: info.targetId,
+      tag: info.tag,
+      text: info.text,
+      url: location.href,
+      state: info.state,
+      viewport: getViewport()
+    };
+    if (this.config.debug) {
+      console.log(`[dataclient] click: ${info.tag} "${info.text}"`);
+    }
+    this.sender.add(action);
+    RrwebTracker.addMarker("click", { tag: info.tag, text: info.text, label: `Click: ${info.text || info.tag}` });
+  }
+  onInput(e) {
+    const target = e.target;
+    if (!target) {
+      return;
+    }
+    const tag = target.tagName?.toLowerCase();
+    if (tag === "input") {
+      const type = target.type?.toLowerCase() || "text";
+      if (!TEXT_INPUT_TYPES.has(type)) {
+        return;
+      }
+    } else if (tag !== "textarea") {
+      return;
+    }
+    this.pendingInputs.add(target);
+    const prev = this.inputTimers.get(target);
+    if (prev) {
+      clearTimeout(prev);
+    }
+    this.inputTimers.set(target, setTimeout(() => {
+      this.inputTimers.delete(target);
+      this.pendingInputs.delete(target);
+      this.recordInput(target);
+    }, this.config.inputDebounce));
+  }
+  recordInput(target) {
+    const rawValue = target.value || "";
+    if (!rawValue) {
+      return;
+    }
+    const info = this.getElementInfo(target);
+    const type = target.type?.toLowerCase() || "";
+    const value = info.masked || type === "password" ? maskText(rawValue) : rawValue;
+    const action = {
+      event: "action",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "input",
+      targetId: info.targetId,
+      tag: info.tag,
+      text: info.text,
+      url: location.href,
+      value,
+      length: rawValue.length,
+      viewport: getViewport()
+    };
+    if (this.config.debug) {
+      console.log(`[dataclient] input: ${info.tag} "${info.text}" \u2192 ${value.length} chars`);
+    }
+    this.sender.add(action);
+    RrwebTracker.addMarker("input", { tag: info.tag, text: info.text, label: `Input: ${info.text || info.tag}` });
+  }
+  onChange(e) {
+    const target = e.target;
+    if (!target) {
+      return;
+    }
+    const info = this.getElementInfo(target);
+    const tag = target.tagName?.toLowerCase();
+    const action = {
+      event: "action",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "change",
+      targetId: info.targetId,
+      tag: info.tag,
+      text: info.text,
+      url: location.href,
+      viewport: getViewport()
+    };
+    if (tag === "select") {
+      const selectValue = target.value;
+      action.value = info.masked ? maskText(selectValue) : selectValue;
+    } else if (tag === "input") {
+      const type = target.type;
+      if (type === "checkbox" || type === "radio") {
+        action.checked = target.checked;
+      }
+    }
+    if (this.config.debug) {
+      console.log(`[dataclient] change: ${info.tag} "${info.text}"`);
+    }
+    this.sender.add(action);
+    RrwebTracker.addMarker("change", { tag: info.tag, text: info.text, label: `Change: ${info.text || info.tag}` });
+  }
+  getElementInfo(el) {
+    const tag = el.tagName?.toLowerCase() || "";
+    let text = "";
+    if (tag === "input" || tag === "textarea") {
+      text = el.placeholder || el.getAttribute("aria-label") || "";
+    } else {
+      for (const child of el.childNodes) {
+        if (child.nodeType === Node.TEXT_NODE) {
+          const t = child.textContent?.trim();
+          if (t) {
+            text += (text ? " " : "") + t;
+          }
+        }
+      }
+      if (!text) {
+        text = el.textContent?.trim().slice(0, 100) || "";
+      }
+    }
+    const masked = isMasked(el);
+    const finalText = masked ? maskText(text) : text;
+    return {
+      tag,
+      text: finalText.slice(0, 100),
+      targetId: getNodeId(el),
+      state: el.disabled ? "disabled" : "enabled",
+      masked
+    };
+  }
+  findMeaningfulElement(el) {
+    let current = el;
+    while (current && current !== document.body) {
+      if (INTERACTIVE_TAGS.has(current.tagName?.toLowerCase())) {
+        return current;
+      }
+      const role = current.getAttribute("role");
+      if (role && INTERACTIVE_ROLES.has(role)) {
+        return current;
+      }
+      current = current.parentElement;
+    }
+    return el;
+  }
+};
+
+// src/trackers/mutation.ts
+var MutationTracker = class {
+  constructor(config, sender, onMutation) {
+    this.config = config;
+    this.sender = sender;
+    this.onMutation = onMutation;
+  }
+  config;
+  sender;
+  onMutation;
+  observer = null;
+  debounceTimer = null;
+  pendingAdds = [];
+  pendingRemoves = [];
+  pendingTextChanges = [];
+  pendingAttrChanges = [];
+  start() {
+    this.observer = new MutationObserver((mutations) => this.handleMutations(mutations));
+    this.observer.observe(document.body, {
+      childList: true,
+      subtree: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: WATCH_ATTRS
+    });
+  }
+  stop() {
+    this.observer?.disconnect();
+    this.observer = null;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+  }
+  beforeUnload() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.flush();
+    }
+  }
+  flush() {
+    this.debounceTimer = null;
+    if (this.pendingAdds.length === 0 && this.pendingRemoves.length === 0 && this.pendingTextChanges.length === 0 && this.pendingAttrChanges.length === 0) {
+      return;
+    }
+    const mutation = {
+      event: "mutation",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      adds: this.pendingAdds,
+      removes: this.pendingRemoves,
+      text_changes: this.pendingTextChanges,
+      attr_changes: this.pendingAttrChanges
+    };
+    if (this.config.debug) {
+      console.log(`[dataclient] mutation: +${this.pendingAdds.length} -${this.pendingRemoves.length} text:${this.pendingTextChanges.length} attr:${this.pendingAttrChanges.length}`);
+    }
+    this.sender.add(mutation);
+    this.onMutation();
+    this.pendingAdds = [];
+    this.pendingRemoves = [];
+    this.pendingTextChanges = [];
+    this.pendingAttrChanges = [];
+  }
+  scheduleFlush() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => this.flush(), this.config.mutationDebounce);
+  }
+  handleMutations(mutations) {
+    for (const m of mutations) {
+      for (const node of m.addedNodes) {
+        if (node.nodeType !== Node.ELEMENT_NODE) {
+          continue;
+        }
+        const el = node;
+        const serialized = serializeNode(el);
+        if (!serialized) {
+          continue;
+        }
+        const parentId = getNodeId(el.parentElement);
+        if (parentId === null) {
+          continue;
+        }
+        this.pendingAdds.push({ parentId, node: serialized });
+      }
+      for (const node of m.removedNodes) {
+        if (node.nodeType !== Node.ELEMENT_NODE) {
+          continue;
+        }
+        const id = getNodeId(node);
+        if (id !== null) {
+          this.pendingRemoves.push(id);
+          removeNodeId(id);
+        }
+      }
+      if (m.type === "characterData" && m.target.parentElement) {
+        const parentId = getNodeId(m.target.parentElement);
+        if (parentId !== null) {
+          const text = m.target.textContent?.trim().slice(0, 200) || "";
+          this.pendingTextChanges.push({ id: parentId, text });
+        }
+      }
+      if (m.type === "attributes" && m.attributeName) {
+        const id = getNodeId(m.target);
+        if (id !== null) {
+          const value = m.target.getAttribute(m.attributeName);
+          this.pendingAttrChanges.push({
+            id,
+            attr: m.attributeName,
+            value: value?.slice(0, 200) ?? null
+          });
+        }
+      }
+    }
+    if (this.pendingAdds.length > 0 || this.pendingRemoves.length > 0 || this.pendingTextChanges.length > 0 || this.pendingAttrChanges.length > 0) {
+      this.scheduleFlush();
+    }
+  }
+};
+
+// src/trackers/snapshot.ts
+var SnapshotTracker = class {
+  constructor(config, sender) {
+    this.config = config;
+    this.sender = sender;
+  }
+  config;
+  sender;
+  lastUrl = "";
+  urlPollTimer = null;
+  checkpointTimer = null;
+  hasMutations = false;
+  start() {
+    this.lastUrl = location.href;
+    this.recordSnapshot();
+    this.urlPollTimer = setInterval(() => this.pollUrl(), 500);
+    this.checkpointTimer = setInterval(() => this.checkpoint(), this.config.checkpointInterval);
+  }
+  stop() {
+    if (this.urlPollTimer) {
+      clearInterval(this.urlPollTimer);
+    }
+    if (this.checkpointTimer) {
+      clearInterval(this.checkpointTimer);
+    }
+  }
+  beforeUnload() {
+    if (this.hasMutations) {
+      this.recordSnapshot();
+    }
+  }
+  markMutation() {
+    this.hasMutations = true;
+  }
+  recordSnapshot() {
+    resetIds();
+    const snapshot = {
+      event: "snapshot",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: location.href,
+      title: document.title,
+      tree: serializeTree(document.body),
+      viewport: getViewport()
+    };
+    if (this.config.debug) {
+      console.log(`[dataclient] snapshot: ${location.href} (${snapshot.tree.length} nodes)`);
+    }
+    this.sender.add(snapshot);
+    this.sender.flush();
+    this.hasMutations = false;
+  }
+  pollUrl() {
+    if (location.href !== this.lastUrl) {
+      const prev = this.lastUrl;
+      this.lastUrl = location.href;
+      if (prev) {
+        if (this.config.debug) {
+          console.log(`[dataclient] URL changed: ${prev} \u2192 ${location.href}`);
+        }
+        this.recordSnapshot();
+      }
+    }
+  }
+  checkpoint() {
+    if (this.hasMutations) {
+      if (this.config.debug) {
+        console.log("[dataclient] checkpoint snapshot");
+      }
+      this.recordSnapshot();
+    }
+  }
+};
+
+// src/utils/identity.ts
+function getDeviceId(key) {
+  let id = localStorage.getItem(key);
+  if (!id) {
+    id = generateId();
+    localStorage.setItem(key, id);
+  }
+  return id;
+}
+function generateId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).substring(2, 12);
+  return `${ts}-${rand}`;
+}
+
+// src/utils/sender.ts
+var STORAGE_KEY = "sc2_pending";
+var MAX_RETRIES = 2;
+var Sender = class {
+  constructor(endpoint, apiKey, batchSize, sessionId, deviceId, flushInterval) {
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+    this.batchSize = batchSize;
+    this.sessionId = sessionId;
+    this.deviceId = deviceId;
+    this.restoreFromStorage();
+    this.timer = setInterval(() => this.flush(), flushInterval);
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        this.flush();
+      }
+    });
+  }
+  endpoint;
+  apiKey;
+  batchSize;
+  sessionId;
+  deviceId;
+  queue = [];
+  timer = null;
+  isFlushing = false;
+  restoreFromStorage() {
+    try {
+      localStorage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+  saveToStorage() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.queue));
+    } catch {
+    }
+  }
+  add(event) {
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0 || this.isFlushing) {
+      return;
+    }
+    this.isFlushing = true;
+    const events = this.queue.splice(0);
+    const batch = this.buildBatch(events);
+    const json = JSON.stringify(batch);
+    const url = `${this.endpoint}?key=${encodeURIComponent(this.apiKey)}`;
+    const success = await this.send(json, url);
+    if (!success) {
+      this.queue.unshift(...events);
+      this.saveToStorage();
+    }
+    this.isFlushing = false;
+  }
+  flushSync() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = this.queue.splice(0);
+    const batch = this.buildBatch(events);
+    const json = JSON.stringify(batch);
+    const url = `${this.endpoint}?key=${encodeURIComponent(this.apiKey)}`;
+    const blob = new Blob([json], { type: "application/json" });
+    const sent = navigator.sendBeacon(url, blob);
+    if (!sent) {
+      this.queue.unshift(...events);
+      this.saveToStorage();
+    }
+  }
+  buildBatch(events) {
+    return {
+      session_id: this.sessionId,
+      device_id: this.deviceId,
+      events,
+      sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+      page_url: location.href,
+      user_agent: navigator.userAgent,
+      screen: {
+        width: screen.width,
+        height: screen.height,
+        viewport_width: window.innerWidth,
+        viewport_height: window.innerHeight
+      }
+    };
+  }
+  async send(json, url) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: json,
+          keepalive: true
+        });
+        if (response.ok) {
+          return true;
+        }
+      } catch {
+      }
+      if (attempt < MAX_RETRIES) {
+        await new Promise((r) => setTimeout(r, (attempt + 1) * 200));
+      }
+    }
+    return false;
+  }
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    this.flushSync();
+  }
+};
+
+// src/index.ts
+var defaults = {
+  endpoint: "https://my.tamsense.com/api/scenes2",
+  debug: false,
+  batchSize: 10,
+  flushInterval: 1e4,
+  checkpointInterval: 3e4,
+  mutationDebounce: 200,
+  inputDebounce: 1e3,
+  sessionIdKey: "sc2_sid",
+  deviceIdKey: "sc2_did",
+  apiKey: ""
+};
+var DataClient = class {
+  sender;
+  trackers = [];
+  config;
+  constructor(options) {
+    this.config = { ...defaults, ...options };
+    const sessionId = generateId();
+    const deviceId = getDeviceId(this.config.deviceIdKey);
+    this.sender = new Sender(
+      this.config.endpoint,
+      this.config.apiKey,
+      this.config.batchSize,
+      sessionId,
+      deviceId,
+      this.config.flushInterval
+    );
+    const snapshotTracker = new SnapshotTracker(this.config, this.sender);
+    const mutationTracker = new MutationTracker(this.config, this.sender, () => snapshotTracker.markMutation());
+    const actionTracker = new ActionTracker(this.config, this.sender);
+    const rrwebTracker = new RrwebTracker(this.config, this.sender);
+    this.trackers = [snapshotTracker, mutationTracker, actionTracker, rrwebTracker];
+    this.trackers.forEach((t) => t.start());
+    const onUnload = () => {
+      this.trackers.forEach((t) => t.beforeUnload?.());
+      this.sender.flushSync();
+    };
+    window.addEventListener("beforeunload", onUnload);
+    window.addEventListener("pagehide", onUnload);
+    console.log(`[dataclient] Initialized. Session: ${sessionId}, Device: ${deviceId}`);
+  }
+  setUser(userId) {
+    this.sender.add({ event: "identify", timestamp: (/* @__PURE__ */ new Date()).toISOString(), user_id: userId });
+  }
+  excludeSession(reason = "") {
+    this.sender.add({ event: "exclude", timestamp: (/* @__PURE__ */ new Date()).toISOString(), reason });
+    this.destroy();
+  }
+  destroy() {
+    this.trackers.forEach((t) => t.stop());
+    this.trackers = [];
+    this.sender.destroy();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataClient
+});
+//# sourceMappingURL=index.cjs.map