@nextlytics/core 0.1.0-canary-1

package/dist/backends/posthog.js

@@ -0,0 +1,96 @@
+function posthogBackend(opts) {
+  const host = (opts.host ?? "https://app.posthog.com").replace(/\/$/, "");
+  const apiKey = opts.apiKey;
+  return {
+    name: "posthog",
+    supportsUpdates: false,
+    async onEvent(event) {
+      const {
+        type,
+        eventId,
+        parentEventId,
+        collectedAt,
+        userContext,
+        clientContext,
+        serverContext,
+        properties,
+        anonymousUserId
+      } = event;
+      const posthogProps = {
+        ...properties,
+        nextlytics_event_id: eventId
+      };
+      if (parentEventId) {
+        posthogProps.nextlytics_parent_event_id = parentEventId;
+      }
+      posthogProps.nextlytics_collected_at = collectedAt;
+      posthogProps.$current_url = `${serverContext.host}${serverContext.path}`;
+      posthogProps.$pathname = serverContext.path;
+      posthogProps.$host = serverContext.host;
+      posthogProps.$ip = serverContext.ip;
+      posthogProps.http_method = serverContext.method;
+      posthogProps.server_collected_at = serverContext.collectedAt;
+      if (serverContext.search && Object.keys(serverContext.search).length > 0) {
+        posthogProps.query_params = serverContext.search;
+      }
+      if (serverContext.requestHeaders && Object.keys(serverContext.requestHeaders).length > 0) {
+        posthogProps.request_headers = serverContext.requestHeaders;
+      }
+      if (serverContext.responseHeaders && Object.keys(serverContext.responseHeaders).length > 0) {
+        posthogProps.response_headers = serverContext.responseHeaders;
+      }
+      const referer = clientContext?.referer ?? serverContext.requestHeaders?.["referer"];
+      if (referer) {
+        posthogProps.$referrer = referer;
+      }
+      const userAgent = clientContext?.userAgent ?? serverContext.requestHeaders?.["user-agent"];
+      if (userAgent) {
+        posthogProps.$user_agent = userAgent;
+      }
+      if (clientContext) {
+        posthogProps.client_collected_at = clientContext.collectedAt;
+        if (clientContext.path) {
+          posthogProps.client_path = clientContext.path;
+        }
+        if (clientContext.locale) {
+          posthogProps.$locale = clientContext.locale;
+        }
+        if (clientContext.screen) {
+          const { screen } = clientContext;
+          if (screen.width) posthogProps.$screen_width = screen.width;
+          if (screen.height) posthogProps.$screen_height = screen.height;
+          if (screen.innerWidth) posthogProps.$viewport_width = screen.innerWidth;
+          if (screen.innerHeight) posthogProps.$viewport_height = screen.innerHeight;
+          if (screen.density) posthogProps.$device_pixel_ratio = screen.density;
+        }
+      }
+      const distinctId = userContext?.userId ?? anonymousUserId ?? "anonymous";
+      const payload = {
+        api_key: apiKey,
+        event: type,
+        distinct_id: distinctId,
+        properties: posthogProps,
+        timestamp: collectedAt
+      };
+      if (userContext?.userId && userContext.traits) {
+        payload.$set = userContext.traits;
+      }
+      const res = await fetch(`${host}/capture/`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`PostHog error ${res.status}: ${text}`);
+      }
+    },
+    updateEvent() {
+    }
+  };
+}
+export {
+  posthogBackend
+};

package/dist/backends/segment.cjs

@@ -0,0 +1,112 @@
+"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);
+var segment_exports = {};
+__export(segment_exports, {
+  segmentBackend: () => segmentBackend
+});
+module.exports = __toCommonJS(segment_exports);
+function segmentBackend(config) {
+  const host = (config.host ?? "https://api.segment.io").replace(/\/$/, "");
+  const authHeader = "Basic " + btoa(config.writeKey + ":");
+  async function send(endpoint, payload) {
+    const res = await fetch(`${host}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: authHeader
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Segment error ${res.status}: ${text}`);
+    }
+  }
+  function buildContext(event) {
+    const ctx = {
+      ip: event.serverContext.ip
+    };
+    if (event.userContext?.traits) {
+      ctx.traits = event.userContext.traits;
+    }
+    if (event.clientContext) {
+      ctx.userAgent = event.clientContext.userAgent;
+      ctx.locale = event.clientContext.locale;
+      ctx.page = {
+        path: event.clientContext.path,
+        referrer: event.clientContext.referer
+      };
+      if (event.clientContext.screen) {
+        ctx.screen = {
+          width: event.clientContext.screen.width,
+          height: event.clientContext.screen.height,
+          innerWidth: event.clientContext.screen.innerWidth,
+          innerHeight: event.clientContext.screen.innerHeight,
+          density: event.clientContext.screen.density
+        };
+      }
+    }
+    return ctx;
+  }
+  function buildProperties(event) {
+    return {
+      parentEventId: event.parentEventId,
+      path: event.serverContext.path,
+      host: event.serverContext.host,
+      method: event.serverContext.method,
+      search: event.serverContext.search,
+      ...event.properties
+    };
+  }
+  return {
+    name: "segment",
+    supportsUpdates: false,
+    async onEvent(event) {
+      const context = buildContext(event);
+      const properties = buildProperties(event);
+      if (event.type === "pageView") {
+        await send("/v1/page", {
+          messageId: event.eventId,
+          anonymousId: event.anonymousUserId,
+          userId: event.userContext?.userId,
+          name: event.serverContext.path,
+          timestamp: event.collectedAt,
+          context,
+          properties
+        });
+      } else {
+        await send("/v1/track", {
+          messageId: event.eventId,
+          anonymousId: event.anonymousUserId,
+          userId: event.userContext?.userId,
+          event: event.type,
+          timestamp: event.collectedAt,
+          context,
+          properties
+        });
+      }
+    },
+    updateEvent() {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  segmentBackend
+});

package/dist/backends/segment.d.mts

@@ -0,0 +1,43 @@
+import { NextlyticsBackend } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/**
+ * Segment backend for Nextlytics
+ *
+ * Sends events to Segment's HTTP Tracking API. Also works with Segment-compatible
+ * destinations like Jitsu.
+ *
+ * ## Segment Usage
+ *
+ * ```typescript
+ * import { segmentBackend } from "@nextlytics/core/backends/segment"
+ *
+ * const analytics = Nextlytics({
+ *   backends: [
+ *     segmentBackend({
+ *       writeKey: process.env.SEGMENT_WRITE_KEY!,
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * ## Jitsu Usage
+ *
+ * ```typescript
+ * segmentBackend({
+ *   writeKey: process.env.JITSU_WRITE_KEY!,
+ *   host: "https://ingest.g.jitsu.com",
+ * })
+ * ```
+ */
+
+type SegmentBackendConfig = {
+    /** Segment write key */
+    writeKey: string;
+    /** API host (default: "https://api.segment.io") */
+    host?: string;
+};
+declare function segmentBackend(config: SegmentBackendConfig): NextlyticsBackend;
+
+export { type SegmentBackendConfig, segmentBackend };

package/dist/backends/segment.d.ts

@@ -0,0 +1,43 @@
+import { NextlyticsBackend } from '../types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/**
+ * Segment backend for Nextlytics
+ *
+ * Sends events to Segment's HTTP Tracking API. Also works with Segment-compatible
+ * destinations like Jitsu.
+ *
+ * ## Segment Usage
+ *
+ * ```typescript
+ * import { segmentBackend } from "@nextlytics/core/backends/segment"
+ *
+ * const analytics = Nextlytics({
+ *   backends: [
+ *     segmentBackend({
+ *       writeKey: process.env.SEGMENT_WRITE_KEY!,
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * ## Jitsu Usage
+ *
+ * ```typescript
+ * segmentBackend({
+ *   writeKey: process.env.JITSU_WRITE_KEY!,
+ *   host: "https://ingest.g.jitsu.com",
+ * })
+ * ```
+ */
+
+type SegmentBackendConfig = {
+    /** Segment write key */
+    writeKey: string;
+    /** API host (default: "https://api.segment.io") */
+    host?: string;
+};
+declare function segmentBackend(config: SegmentBackendConfig): NextlyticsBackend;
+
+export { type SegmentBackendConfig, segmentBackend };

package/dist/backends/segment.js

@@ -0,0 +1,88 @@
+function segmentBackend(config) {
+  const host = (config.host ?? "https://api.segment.io").replace(/\/$/, "");
+  const authHeader = "Basic " + btoa(config.writeKey + ":");
+  async function send(endpoint, payload) {
+    const res = await fetch(`${host}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: authHeader
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Segment error ${res.status}: ${text}`);
+    }
+  }
+  function buildContext(event) {
+    const ctx = {
+      ip: event.serverContext.ip
+    };
+    if (event.userContext?.traits) {
+      ctx.traits = event.userContext.traits;
+    }
+    if (event.clientContext) {
+      ctx.userAgent = event.clientContext.userAgent;
+      ctx.locale = event.clientContext.locale;
+      ctx.page = {
+        path: event.clientContext.path,
+        referrer: event.clientContext.referer
+      };
+      if (event.clientContext.screen) {
+        ctx.screen = {
+          width: event.clientContext.screen.width,
+          height: event.clientContext.screen.height,
+          innerWidth: event.clientContext.screen.innerWidth,
+          innerHeight: event.clientContext.screen.innerHeight,
+          density: event.clientContext.screen.density
+        };
+      }
+    }
+    return ctx;
+  }
+  function buildProperties(event) {
+    return {
+      parentEventId: event.parentEventId,
+      path: event.serverContext.path,
+      host: event.serverContext.host,
+      method: event.serverContext.method,
+      search: event.serverContext.search,
+      ...event.properties
+    };
+  }
+  return {
+    name: "segment",
+    supportsUpdates: false,
+    async onEvent(event) {
+      const context = buildContext(event);
+      const properties = buildProperties(event);
+      if (event.type === "pageView") {
+        await send("/v1/page", {
+          messageId: event.eventId,
+          anonymousId: event.anonymousUserId,
+          userId: event.userContext?.userId,
+          name: event.serverContext.path,
+          timestamp: event.collectedAt,
+          context,
+          properties
+        });
+      } else {
+        await send("/v1/track", {
+          messageId: event.eventId,
+          anonymousId: event.anonymousUserId,
+          userId: event.userContext?.userId,
+          event: event.type,
+          timestamp: event.collectedAt,
+          context,
+          properties
+        });
+      }
+    },
+    updateEvent() {
+    }
+  };
+}
+export {
+  segmentBackend
+};

package/dist/client.cjs

@@ -0,0 +1,171 @@
+"use strict";
+"use client";
+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);
+var client_exports = {};
+__export(client_exports, {
+  NextlyticsClient: () => NextlyticsClient,
+  useNextlytics: () => useNextlytics
+});
+module.exports = __toCommonJS(client_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_server_component_context = require("./server-component-context");
+var import_template = require("./template");
+const templateFunctions = {
+  q: (v) => JSON.stringify(v ?? null),
+  json: (v) => JSON.stringify(v ?? null)
+};
+const compiledCache = {};
+const NextlyticsContext = (0, import_react.createContext)(null);
+function createClientContext() {
+  const isBrowser = typeof window !== "undefined";
+  return {
+    collectedAt: /* @__PURE__ */ new Date(),
+    referer: isBrowser ? document.referrer || void 0 : void 0,
+    path: isBrowser ? window.location.pathname : void 0,
+    screen: {
+      width: isBrowser ? window.screen.width : void 0,
+      height: isBrowser ? window.screen.height : void 0,
+      innerWidth: isBrowser ? window.innerWidth : void 0,
+      innerHeight: isBrowser ? window.innerHeight : void 0,
+      density: isBrowser ? window.devicePixelRatio : void 0
+    },
+    userAgent: isBrowser ? navigator.userAgent : void 0,
+    locale: isBrowser ? navigator.language : void 0
+  };
+}
+function getCompiledTemplate(templateId, itemIndex, item) {
+  const cacheKey = `${templateId}:${itemIndex}`;
+  if (!compiledCache[cacheKey]) {
+    compiledCache[cacheKey] = {
+      src: item.src ? (0, import_template.compile)(item.src) : void 0,
+      body: item.body ? (0, import_template.compile)(item.body) : void 0
+    };
+  }
+  return compiledCache[cacheKey];
+}
+function executeTemplatedScripts(scripts, templates) {
+  if (!scripts || typeof window === "undefined") return;
+  for (const script of scripts) {
+    if (script.type !== "script-template") {
+      console.warn(`[Nextlytics] unsupported script type ${script.type} `);
+      continue;
+    }
+    const template = templates[script.templateId];
+    if (!template) {
+      console.warn(`[Nextlytics] Missing template: ${script.templateId}`);
+      continue;
+    }
+    const params = script.params;
+    for (let i = 0; i < template.items.length; i++) {
+      const item = template.items[i];
+      const compiled = getCompiledTemplate(script.templateId, i, item);
+      const src = compiled.src ? (0, import_template.apply)(compiled.src, params, templateFunctions) : void 0;
+      if (item.singleton && src && document.querySelector(`script[src="${src}"]`)) {
+        continue;
+      }
+      const el = document.createElement("script");
+      if (src) {
+        el.src = src;
+      }
+      if (compiled.body) {
+        el.textContent = (0, import_template.apply)(compiled.body, params, templateFunctions);
+      }
+      if (item.async) {
+        el.async = true;
+      }
+      document.head.appendChild(el);
+    }
+  }
+}
+async function sendEvent(requestId, type, payload) {
+  try {
+    const response = await fetch("/api/event", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [import_server_component_context.headers.pageRenderId]: requestId
+      },
+      body: JSON.stringify({ type, payload })
+    });
+    if (response.status === 404) {
+      console.error(
+        "[Nextlytics] In order for NextlyticsClient to work, you must mount nextlyticsRouteHandler to /api/event"
+      );
+      return { ok: false };
+    }
+    const data = await response.json().catch(() => ({ ok: response.ok }));
+    return { ok: data.ok ?? response.ok, scripts: data.scripts };
+  } catch (error) {
+    console.error("[Nextlytics] Failed to send event:", error);
+    return { ok: false };
+  }
+}
+const initializedRequestIds = /* @__PURE__ */ new Set();
+function NextlyticsClient(props) {
+  const requestId = props.ctx?.requestId ?? props.requestId ?? "";
+  const scripts = props.ctx?.scripts ?? props.scripts;
+  const templates = props.ctx?.templates ?? props.templates ?? {};
+  (0, import_react.useEffect)(() => {
+    if (initializedRequestIds.has(requestId)) return;
+    initializedRequestIds.add(requestId);
+    if (scripts && Object.keys(templates).length > 0) {
+      executeTemplatedScripts(scripts, templates);
+    }
+    const clientContext = createClientContext();
+    sendEvent(requestId, "client-init", clientContext).then(
+      ({ scripts: responseScripts }) => {
+        if (responseScripts) {
+          executeTemplatedScripts(responseScripts, templates);
+        }
+      }
+    );
+  }, [requestId, scripts, templates]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NextlyticsContext.Provider, { value: { requestId, templates }, children: props.children });
+}
+function useNextlytics() {
+  const context = (0, import_react.useContext)(NextlyticsContext);
+  if (!context) {
+    throw new Error(
+      "[Nextlytics] useNextlytics() must be used within a component wrapped by <NextlyticsServer>. Add <NextlyticsServer> at the top of your layout.tsx file."
+    );
+  }
+  const { requestId, templates } = context;
+  const send = (0, import_react.useCallback)(
+    async (eventName, opts) => {
+      const result = await sendEvent(requestId, "client-event", {
+        name: eventName,
+        props: opts?.props,
+        collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        clientContext: createClientContext()
+      });
+      if (result.scripts) {
+        executeTemplatedScripts(result.scripts, templates);
+      }
+      return { ok: result.ok };
+    },
+    [requestId, templates]
+  );
+  return { sendEvent: send };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NextlyticsClient,
+  useNextlytics
+});

package/dist/client.d.mts

@@ -0,0 +1,29 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { TemplatizedScriptInsertion, JavascriptTemplate } from './types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/** Context object for Pages Router integration */
+type NextlyticsContext = {
+    requestId: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
+};
+declare function NextlyticsClient(props: {
+    ctx?: NextlyticsContext;
+    requestId?: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+type NextlyticsClientApi = {
+    sendEvent: (eventName: string, opts?: {
+        props?: Record<string, unknown>;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+};
+declare function useNextlytics(): NextlyticsClientApi;
+
+export { NextlyticsClient, type NextlyticsClientApi, type NextlyticsContext, useNextlytics };

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { TemplatizedScriptInsertion, JavascriptTemplate } from './types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/** Context object for Pages Router integration */
+type NextlyticsContext = {
+    requestId: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
+};
+declare function NextlyticsClient(props: {
+    ctx?: NextlyticsContext;
+    requestId?: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+type NextlyticsClientApi = {
+    sendEvent: (eventName: string, opts?: {
+        props?: Record<string, unknown>;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+};
+declare function useNextlytics(): NextlyticsClientApi;
+
+export { NextlyticsClient, type NextlyticsClientApi, type NextlyticsContext, useNextlytics };