luchy 0.0.1 → 0.2.0

package/dist/script/luchy.min.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 || {});

package/dist/server.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Server-side tracking.
+ *
+ * The browser tracker (`./index.ts`) can only see what happens in a page. A
+ * server sees what the application actually *did* — an order placed, a payment
+ * recorded, a webhook processed — and those are usually the events worth
+ * having. This entry point carries no browser globals (`window`, `document`,
+ * `location`, `navigator`), so it runs in Node, Bun, Deno and Cloudflare
+ * Workers.
+ *
+ * It exists mostly so that callers stop hand-rolling `fetch` against the
+ * ingest API: doing that is how the `props`/`payload` field-name split shipped
+ * unnoticed, since nothing typed the wire format for a non-browser sender.
+ *
+ * The transport now lives in `./api`, generated from the API's own OpenAPI
+ * document, so the wire format is no longer restated here at all. This module
+ * is the ergonomic face of it: two methods, no client object to hold.
+ */
+export type LuchyServerOptions = {
+    apiKey: string;
+    /** Defaults to the hosted ingest API. */
+    endpoint?: string;
+    /**
+     * Called when an event fails to reach the ingest API. Analytics must never
+     * break the request it is describing, so failures are swallowed by default —
+     * pass this to log them.
+     */
+    onError?: (error: unknown) => void;
+};
+/** A property bag. Nested objects are not supported by the ingest API. */
+export type LuchyPayload = Record<string, string | number | boolean>;
+export type LuchyServerEvent = {
+    /** The event name, e.g. `order:placed`. */
+    name: string;
+    /** Where it happened — a route, not a raw URL with ids in it. */
+    pathname: string;
+    /** Free-form category, e.g. `server`, `webhook`, `cron`. */
+    type?: string;
+    payload?: LuchyPayload;
+    /** Forward the end user's UA when the event was caused by a request. */
+    userAgent?: string;
+    language?: string;
+    /** ISO country code. Cloudflare deployments can leave this to the server. */
+    country?: string;
+};
+export type LuchyServerPageview = {
+    pathname: string;
+    referrer?: string;
+    userAgent?: string;
+    language?: string;
+    country?: string;
+};
+export type LuchyServerTracker = {
+    trackEvent(event: LuchyServerEvent): Promise<void>;
+    trackPageview(pageview: LuchyServerPageview): Promise<void>;
+};
+/**
+ * Creates a server-side tracker. Every method resolves rather than rejects —
+ * see `onError`.
+ *
+ * ```ts
+ * const luchy = createServerTracker({ apiKey: process.env.LUCHY_API_KEY! });
+ * await luchy.trackEvent({
+ *   name: 'order:placed',
+ *   pathname: '/checkout',
+ *   payload: { plan: 'pro', amount: 29 }
+ * });
+ * ```
+ */
+export declare function createServerTracker(options: LuchyServerOptions): LuchyServerTracker;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAErE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D,CAAC;AAcF;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,kBAAkB,GAC1B,kBAAkB,CAkCpB"}

package/dist/server.js

@@ -0,0 +1,40 @@
+import { createLuchyClient } from "./api/index.js";
+const DEFAULT_ENDPOINT = "https://api.luchy.app/ingest";
+function apiBaseFrom(endpoint) {
+  const withoutSlash = endpoint.replace(/\/+$/, "");
+  return withoutSlash.replace(/\/ingest$/, "");
+}
+function createServerTracker(options) {
+  const client = createLuchyClient({
+    apiKey: options.apiKey,
+    endpoint: apiBaseFrom(options.endpoint || DEFAULT_ENDPOINT),
+    onError: options.onError
+  });
+  return {
+    async trackEvent(event) {
+      const body = {
+        name: event.name,
+        type: event.type,
+        pathname: event.pathname,
+        payload: event.payload,
+        userAgent: event.userAgent,
+        language: event.language,
+        country: event.country
+      };
+      await client.trackEvent(body);
+    },
+    async trackPageview(pageview) {
+      const body = {
+        pathname: pageview.pathname,
+        referrer: pageview.referrer,
+        userAgent: pageview.userAgent,
+        language: pageview.language,
+        country: pageview.country
+      };
+      await client.trackPageview(body);
+    }
+  };
+}
+export {
+  createServerTracker
+};

package/package.json

@@ -1,12 +1,72 @@
 {
   "name": "luchy",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
-  "scripts": {},
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {},
-  "devDependencies": {}
+  "version": "0.2.0",
+  "description": "Luchy tracking - browser script + server-side tracker",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./react-router": {
+      "types": "./dist/react-router.d.ts",
+      "import": "./dist/react-router.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build && vite build --minify false && bunx tsx build.ts && bun run build:lib",
+    "upload": "bunx tsx upload.ts",
+    "deploy": "bun run build && bun run upload",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build:lib": "vite build --config vite.lib.config.ts",
+    "generate": "openapi-typescript openapi.json -o src/api/schema.d.ts"
+  },
+  "keywords": [
+    "analytics",
+    "tracking",
+    "luchy",
+    "pageview",
+    "events"
+  ],
+  "author": "Willy Ovalle",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luchyio/luchy.git",
+    "directory": "packages/tracker"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.0",
+    "jsdom": "^25.0.1",
+    "openapi-typescript": "^7.13.0",
+    "terser": "^5.37.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vite": "^6.0.3",
+    "vite-plugin-compression": "^0.5.1",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.8",
+    "wrangler": "^4.43.0"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.17.0"
+  }
 }

package/index.js

@@ -1 +0,0 @@
-export const check = "soon";