@pulsekit/next 0.0.1

package/dist/client.d.mts

@@ -0,0 +1,7 @@
+interface PulseTrackerProps {
+    endpoint?: string;
+    excludePaths?: string[];
+}
+declare function PulseTracker({ endpoint, excludePaths }: PulseTrackerProps): null;
+
+export { PulseTracker, type PulseTrackerProps };

package/dist/client.mjs

@@ -0,0 +1,99 @@
+"use client";
+// src/PulseTracker.tsx
+import { useEffect, useRef } from "react";
+function getSessionId() {
+  const key = "pulse_session_id";
+  let id = sessionStorage.getItem(key);
+  if (!id) {
+    id = crypto.randomUUID();
+    sessionStorage.setItem(key, id);
+  }
+  return id;
+}
+function PulseTracker({ endpoint = "/api/pulse", excludePaths }) {
+  const vitalsRef = useRef({});
+  const hasSentVitalsRef = useRef(false);
+  const sessionIdRef = useRef(null);
+  useEffect(() => {
+    sessionIdRef.current = getSessionId();
+  }, []);
+  useEffect(() => {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    document.cookie = `pulse_tz=${encodeURIComponent(tz)}; path=/; max-age=${60 * 60 * 24 * 365}; SameSite=Lax`;
+    if (excludePaths?.includes(window.location.pathname)) return;
+    const sessionId = getSessionId();
+    sessionIdRef.current = sessionId;
+    fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        type: "pageview",
+        path: window.location.pathname,
+        sessionId
+      })
+    }).catch(() => {
+    });
+  }, [endpoint, excludePaths]);
+  useEffect(() => {
+    if (excludePaths?.includes(window.location.pathname)) return;
+    import("web-vitals").then(({ onLCP, onINP, onCLS, onFCP, onTTFB }) => {
+      onLCP((m) => {
+        vitalsRef.current.lcp = m.value;
+      });
+      onINP((m) => {
+        vitalsRef.current.inp = m.value;
+      }, { reportAllChanges: true });
+      onCLS((m) => {
+        vitalsRef.current.cls = m.value;
+      }, { reportAllChanges: true });
+      onFCP((m) => {
+        vitalsRef.current.fcp = m.value;
+      });
+      onTTFB((m) => {
+        vitalsRef.current.ttfb = m.value;
+      });
+    }).catch(() => {
+    });
+    function sendVitals() {
+      if (hasSentVitalsRef.current) return;
+      const metrics = vitalsRef.current;
+      if (Object.keys(metrics).length === 0) return;
+      hasSentVitalsRef.current = true;
+      const body = JSON.stringify({
+        type: "vitals",
+        path: window.location.pathname,
+        sessionId: sessionIdRef.current,
+        meta: { ...metrics }
+      });
+      if (typeof navigator.sendBeacon === "function") {
+        navigator.sendBeacon(
+          endpoint,
+          new Blob([body], { type: "application/json" })
+        );
+      } else {
+        fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body,
+          keepalive: true
+        }).catch(() => {
+        });
+      }
+    }
+    function onVisibilityChange() {
+      if (document.visibilityState === "hidden") {
+        sendVitals();
+      }
+    }
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    window.addEventListener("pagehide", sendVitals);
+    return () => {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.removeEventListener("pagehide", sendVitals);
+    };
+  }, [endpoint, excludePaths]);
+  return null;
+}
+export {
+  PulseTracker
+};

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { PulseEventPayload } from '@pulsekit/core';
+
+interface PulseHandlerConfig {
+    supabase: SupabaseClient;
+    config?: {
+        allowLocalhost?: boolean;
+        ignorePaths?: string[];
+        siteId?: string;
+    };
+}
+interface PulseRequestBody extends PulseEventPayload {
+    siteId?: string;
+}
+
+declare function createPulseHandler({ supabase, config }: PulseHandlerConfig): (req: NextRequest) => Promise<NextResponse<unknown>>;
+
+interface RefreshHandlerConfig {
+    supabase: SupabaseClient;
+    daysBack?: number;
+}
+declare function createRefreshHandler({ supabase, daysBack, }: RefreshHandlerConfig): () => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    ok: boolean;
+}>>;
+
+/**
+ * Server-side helper that reads the browser timezone from the cookie
+ * set by <PulseTimezone />. Falls back to "UTC" if not set.
+ */
+declare function getPulseTimezone(): Promise<string>;
+
+export { type PulseHandlerConfig, type PulseRequestBody, type RefreshHandlerConfig, createPulseHandler, createRefreshHandler, getPulseTimezone };

package/dist/index.mjs

@@ -0,0 +1,92 @@
+// src/createPulseHandler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var EventSchema = z.object({
+  type: z.enum(["pageview", "custom", "vitals"]),
+  path: z.string().min(1),
+  sessionId: z.string().optional(),
+  meta: z.record(z.unknown()).optional(),
+  siteId: z.string().optional()
+});
+function createPulseHandler({ supabase, config }) {
+  return async function handler(req) {
+    if (req.method !== "POST") {
+      return new NextResponse("Method Not Allowed", { status: 405 });
+    }
+    const origin = req.headers.get("origin") ?? "";
+    const referer = req.headers.get("referer") ?? "";
+    const isLocalhost = origin.includes("localhost") || referer.includes("localhost");
+    if (!isLocalhost || config?.allowLocalhost === false) {
+    }
+    let json;
+    try {
+      json = await req.json();
+    } catch {
+      return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+    }
+    const parse = EventSchema.safeParse(json);
+    if (!parse.success) {
+      return NextResponse.json({ error: "Invalid payload" }, { status: 400 });
+    }
+    const event = parse.data;
+    const siteId = event.siteId ?? config?.siteId ?? "default";
+    const country = req.headers.get("x-vercel-ip-country") ?? null;
+    const region = req.headers.get("x-vercel-ip-country-region") ?? null;
+    const city = req.headers.get("x-vercel-ip-city") ?? null;
+    const timezone = req.headers.get("x-vercel-ip-timezone") ?? null;
+    const latRaw = req.headers.get("x-vercel-ip-latitude");
+    const lngRaw = req.headers.get("x-vercel-ip-longitude");
+    const latitude = latRaw ? parseFloat(latRaw) : null;
+    const longitude = lngRaw ? parseFloat(lngRaw) : null;
+    try {
+      const { error } = await supabase.schema("analytics").from("pulse_events").insert({
+        site_id: siteId,
+        session_id: event.sessionId ?? null,
+        path: event.path,
+        event_type: event.type,
+        meta: event.meta ?? null,
+        country,
+        region,
+        city,
+        timezone,
+        latitude,
+        longitude
+      });
+      if (error) throw error;
+    } catch (e) {
+      console.error(e);
+      return NextResponse.json(
+        { error: "Failed to log event" },
+        { status: 500 }
+      );
+    }
+    return NextResponse.json({ ok: true });
+  };
+}
+
+// src/createRefreshHandler.ts
+import { NextResponse as NextResponse2 } from "next/server";
+function createRefreshHandler({
+  supabase,
+  daysBack = 7
+}) {
+  return async function handler() {
+    const { error } = await supabase.schema("analytics").rpc("pulse_refresh_aggregates", { days_back: daysBack });
+    if (error) {
+      return NextResponse2.json({ error: error.message }, { status: 500 });
+    }
+    return NextResponse2.json({ ok: true });
+  };
+}
+
+// src/getPulseTimezone.ts
+import { cookies } from "next/headers";
+async function getPulseTimezone() {
+  const cookieStore = await cookies();
+  return cookieStore.get("pulse_tz")?.value ?? "UTC";
+}
+export {
+  createPulseHandler,
+  createRefreshHandler,
+  getPulseTimezone
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pulsekit/next",
+  "version": "0.0.1",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./client": {
+      "import": "./dist/client.mjs",
+      "types": "./dist/client.d.mts"
+    }
+  },
+  "dependencies": {
+    "web-vitals": "^4.2.0",
+    "zod": "^3.24.0",
+    "@pulsekit/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "next": "^15.0.0",
+    "react": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": ">=2.0.0",
+    "next": ">=14.0.0",
+    "react": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  }
+}