luchy 0.0.1 → 0.2.0

package/dist/script/luchy.js

@@ -0,0 +1,357 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+(function(exports) {
+  "use strict";
+  function sendEvent(options) {
+    return __async(this, null, function* () {
+      const { endpoint, apiKey, data, onError } = options;
+      try {
+        yield fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(data),
+          keepalive: true
+          // Important for page unload events
+        });
+      } catch (error) {
+        onError == null ? void 0 : onError(error);
+      }
+    });
+  }
+  function collectBrowserData() {
+    var _a;
+    return {
+      userAgent: navigator.userAgent,
+      language: navigator.language || ((_a = navigator.languages) == null ? void 0 : _a[0]) || "en"
+    };
+  }
+  function luchy(options) {
+    const endpoint = options.endpoint || "https://api.luchy.app/ingest";
+    const { apiKey, trackLocalhost = false } = options;
+    const shouldTrack = () => {
+      if (trackLocalhost) return true;
+      return location.hostname !== "localhost" && location.hostname !== "127.0.0.1";
+    };
+    function trackPageview(data) {
+      return __async(this, null, function* () {
+        if (!shouldTrack()) return;
+        const browserData = collectBrowserData();
+        const pathname = (data == null ? void 0 : data.pathname) || location.pathname;
+        const referrer = (data == null ? void 0 : data.referrer) || document.referrer || void 0;
+        yield sendEvent({
+          endpoint: `${endpoint}/pageview`,
+          apiKey,
+          data: __spreadValues({
+            pathname,
+            referrer
+          }, browserData)
+        });
+      });
+    }
+    function trackEvent(name, payload, options2) {
+      return __async(this, null, function* () {
+        if (!shouldTrack()) return;
+        const browserData = collectBrowserData();
+        const pathname = location.pathname;
+        yield sendEvent({
+          endpoint: `${endpoint}/event`,
+          apiKey,
+          data: __spreadValues({
+            name,
+            type: options2 == null ? void 0 : options2.type,
+            pathname,
+            // `payload`, NOT `props`. The ingest endpoint validates with a
+            // non-passthrough zod object, so an unknown key is stripped and the
+            // event is stored with no properties at all — 200, success, no data.
+            payload
+          }, browserData)
+        });
+      });
+    }
+    let autoPageviewsEnabled = false;
+    let autoOutboundEnabled = false;
+    let autoEventsEnabled = false;
+    let hashRoutingEnabled = false;
+    let pageEnteredAt = 0;
+    let currentPathname = "";
+    let pageleaveSent = false;
+    let trackedLocation = "";
+    function locationKey() {
+      return `${location.pathname}${location.search || ""}${location.hash || ""}`;
+    }
+    function trackNavigation() {
+      const next = locationKey();
+      if (next === trackedLocation) return;
+      sendPageleave();
+      trackedLocation = next;
+      trackPageview();
+      resetPageTiming();
+    }
+    function sendPageleave() {
+      if (pageleaveSent || !currentPathname || !pageEnteredAt) return;
+      pageleaveSent = true;
+      const duration = Date.now() - pageEnteredAt;
+      trackEvent(
+        "__pageleave",
+        { duration, pathname: currentPathname },
+        { type: "__internal" }
+      );
+    }
+    function resetPageTiming() {
+      pageEnteredAt = Date.now();
+      currentPathname = location.pathname;
+      pageleaveSent = false;
+    }
+    let visibilityListener = null;
+    let pagehideListener = null;
+    let originalPushState = null;
+    let originalReplaceState = null;
+    let popstateListener = null;
+    let hashchangeListener = null;
+    let clickListener = null;
+    let dataEventClickListener = null;
+    function enableAutoPageviews() {
+      if (autoPageviewsEnabled) return;
+      autoPageviewsEnabled = true;
+      trackedLocation = locationKey();
+      trackPageview();
+      resetPageTiming();
+      if (!originalPushState) {
+        originalPushState = history.pushState.bind(history);
+      }
+      if (!originalReplaceState) {
+        originalReplaceState = history.replaceState.bind(history);
+      }
+      history.pushState = function(data, unused, url) {
+        originalPushState.apply(this, [data, unused, url]);
+        trackNavigation();
+      };
+      history.replaceState = function(data, unused, url) {
+        originalReplaceState.apply(this, [data, unused, url]);
+        trackNavigation();
+      };
+      popstateListener = () => {
+        trackNavigation();
+      };
+      window.addEventListener("popstate", popstateListener);
+      visibilityListener = () => {
+        if (document.visibilityState === "hidden") {
+          sendPageleave();
+        } else if (document.visibilityState === "visible") {
+          resetPageTiming();
+        }
+      };
+      document.addEventListener("visibilitychange", visibilityListener);
+      pagehideListener = () => sendPageleave();
+      window.addEventListener("pagehide", pagehideListener);
+    }
+    function disableAutoPageviews() {
+      if (!autoPageviewsEnabled) return;
+      autoPageviewsEnabled = false;
+      if (originalPushState) {
+        history.pushState = originalPushState;
+      }
+      if (originalReplaceState) {
+        history.replaceState = originalReplaceState;
+      }
+      if (popstateListener) {
+        window.removeEventListener("popstate", popstateListener);
+        popstateListener = null;
+      }
+      if (visibilityListener) {
+        document.removeEventListener("visibilitychange", visibilityListener);
+        visibilityListener = null;
+      }
+      if (pagehideListener) {
+        window.removeEventListener("pagehide", pagehideListener);
+        pagehideListener = null;
+      }
+    }
+    function enableHashRouting() {
+      if (hashRoutingEnabled) return;
+      hashRoutingEnabled = true;
+      hashchangeListener = () => trackNavigation();
+      window.addEventListener("hashchange", hashchangeListener);
+    }
+    function disableHashRouting() {
+      if (!hashRoutingEnabled) return;
+      hashRoutingEnabled = false;
+      if (hashchangeListener) {
+        window.removeEventListener("hashchange", hashchangeListener);
+        hashchangeListener = null;
+      }
+    }
+    function enableAutoOutboundTracking() {
+      if (autoOutboundEnabled) return;
+      autoOutboundEnabled = true;
+      clickListener = (event) => {
+        var _a;
+        const link = (_a = event.target) == null ? void 0 : _a.closest("a");
+        if (!link) return;
+        if (link.closest("[data-luchy-event]")) return;
+        const href = link.href;
+        if (!href) return;
+        try {
+          const url = new URL(href);
+          if (url.hostname !== location.hostname) {
+            trackEvent("Outbound Link", { url: href }, { type: "click" });
+          }
+        } catch (e) {
+        }
+      };
+      document.addEventListener("click", clickListener);
+    }
+    function disableAutoOutboundTracking() {
+      if (!autoOutboundEnabled) return;
+      autoOutboundEnabled = false;
+      if (clickListener) {
+        document.removeEventListener("click", clickListener);
+        clickListener = null;
+      }
+    }
+    function enableAutoEvents() {
+      if (autoEventsEnabled) return;
+      autoEventsEnabled = true;
+      dataEventClickListener = (event) => {
+        var _a;
+        const target = (_a = event.target) == null ? void 0 : _a.closest(
+          "[data-luchy-event]"
+        );
+        if (!target) return;
+        const name = target.getAttribute("data-luchy-event");
+        if (!name) return;
+        const payload = {};
+        for (const attr of Array.from(target.attributes)) {
+          const prefix = attr.name.startsWith("data-luchy-payload-") ? "data-luchy-payload-" : attr.name.startsWith("data-luchy-prop-") ? "data-luchy-prop-" : null;
+          if (!prefix) continue;
+          const key = attr.name.slice(prefix.length).replace(/-/g, "_");
+          payload[key] = attr.value;
+        }
+        trackEvent(
+          name,
+          Object.keys(payload).length > 0 ? payload : void 0,
+          { type: "click" }
+        );
+      };
+      document.addEventListener("click", dataEventClickListener);
+    }
+    function disableAutoEvents() {
+      if (!autoEventsEnabled) return;
+      autoEventsEnabled = false;
+      if (dataEventClickListener) {
+        document.removeEventListener("click", dataEventClickListener);
+        dataEventClickListener = null;
+      }
+    }
+    function setOptions(options2) {
+      if (options2.autoPageviews !== void 0) {
+        if (options2.autoPageviews) {
+          enableAutoPageviews();
+        } else {
+          disableAutoPageviews();
+        }
+      }
+      if (options2.autoOutbound !== void 0) {
+        if (options2.autoOutbound) {
+          enableAutoOutboundTracking();
+        } else {
+          disableAutoOutboundTracking();
+        }
+      }
+      if (options2.autoEvents !== void 0) {
+        if (options2.autoEvents) {
+          enableAutoEvents();
+        } else {
+          disableAutoEvents();
+        }
+      }
+      if (options2.hashRouting !== void 0) {
+        if (options2.hashRouting) {
+          enableHashRouting();
+        } else {
+          disableHashRouting();
+        }
+      }
+    }
+    return {
+      trackPageview,
+      trackEvent,
+      setOptions
+    };
+  }
+  if (typeof document !== "undefined" && document.currentScript) {
+    const script = document.currentScript;
+    const apiKey = script.getAttribute("data-api-key");
+    const endpoint = script.getAttribute("data-endpoint") || void 0;
+    const trackLocalhost = script.hasAttribute("data-track-localhost");
+    if (apiKey) {
+      const tracker = luchy({
+        apiKey,
+        endpoint,
+        trackLocalhost
+      });
+      const autoPageviewsAttr = script.getAttribute("data-auto-pageviews");
+      const autoOutboundAttr = script.getAttribute("data-auto-outbound");
+      const autoEventsAttr = script.getAttribute("data-auto-events");
+      const hashRoutingAttr = script.getAttribute("data-hash-routing");
+      const options = {};
+      if (autoPageviewsAttr !== null) {
+        options.autoPageviews = autoPageviewsAttr !== "false";
+      }
+      if (autoOutboundAttr !== null) {
+        options.autoOutbound = autoOutboundAttr !== "false";
+      }
+      if (autoEventsAttr !== null) {
+        options.autoEvents = autoEventsAttr !== "false";
+      }
+      if (hashRoutingAttr !== null) {
+        options.hashRouting = hashRoutingAttr !== "false";
+      }
+      tracker.setOptions(__spreadValues({
+        autoPageviews: true,
+        autoOutbound: true,
+        autoEvents: true,
+        hashRouting: true
+      }, options));
+      window.luchy = tracker;
+    }
+  }
+  exports.luchy = luchy;
+})(this.luchy = this.luchy || {});