@nextlytics/core 0.1.0-canary-1

package/dist/index.js

@@ -0,0 +1,12 @@
+import { Nextlytics, NextlyticsServer } from "./server";
+import { NextlyticsClient, useNextlytics } from "./client";
+import { getNextlyticsProps } from "./pages-router";
+import { loggingBackend } from "./backends/logging";
+export {
+  Nextlytics,
+  NextlyticsClient,
+  NextlyticsServer,
+  getNextlyticsProps,
+  loggingBackend,
+  useNextlytics
+};

package/dist/middleware.cjs

@@ -0,0 +1,204 @@
+"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 middleware_exports = {};
+__export(middleware_exports, {
+  createNextlyticsMiddleware: () => createNextlyticsMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_server = require("next/server");
+var import_server_component_context = require("./server-component-context");
+var import_uitils = require("./uitils");
+var import_anonymous_user = require("./anonymous-user");
+function resolveBackends(config, ctx) {
+  const backends = config.backends || [];
+  return backends.map((backend) => typeof backend === "function" ? backend(ctx) : backend).filter((b) => b !== null);
+}
+function collectTemplates(backends) {
+  const templates = {};
+  for (const backend of backends) {
+    if (backend.getClientSideTemplates) {
+      Object.assign(templates, backend.getClientSideTemplates());
+    }
+  }
+  return templates;
+}
+function createRequestContext(request) {
+  return {
+    headers: request.headers,
+    cookies: request.cookies
+  };
+}
+function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
+  const { eventEndpoint } = config;
+  return async (request) => {
+    const pathname = request.nextUrl.pathname;
+    const reqInfo = (0, import_uitils.getRequestInfo)(request);
+    if (pathname === eventEndpoint) {
+      if (request.method === "POST") {
+        return handleEventPost(request, config, dispatchEvent, updateEvent);
+      }
+      return Response.json({ error: "Method not allowed" }, { status: 405 });
+    }
+    if (reqInfo.isNextjsInternal || reqInfo.isPrefetch || reqInfo.isStaticFile) {
+      return import_server.NextResponse.next();
+    }
+    const pageRenderId = (0, import_uitils.generateId)();
+    const serverContext = (0, import_uitils.createServerContext)(request);
+    const response = import_server.NextResponse.next();
+    const ctx = createRequestContext(request);
+    const { anonId } = await (0, import_anonymous_user.resolveAnonymousUser)({ ctx, serverContext, config, response });
+    const backends = resolveBackends(config, ctx);
+    const templates = collectTemplates(backends);
+    let scripts = [];
+    if (config.pageViewMode !== "client-init") {
+      if (config.excludePaths?.(pathname)) {
+        (0, import_server_component_context.serializeServerComponentContext)(response, {
+          pageRenderId,
+          pathname: request.nextUrl.pathname,
+          search: request.nextUrl.search,
+          scripts,
+          templates
+        });
+        return response;
+      }
+      const isApiPath = config.isApiPath(pathname);
+      if (isApiPath && config.excludeApiCalls) {
+        (0, import_server_component_context.serializeServerComponentContext)(response, {
+          pageRenderId,
+          pathname: request.nextUrl.pathname,
+          search: request.nextUrl.search,
+          scripts,
+          templates
+        });
+        return response;
+      }
+      const userContext = await getUserContext(config, ctx);
+      const pageViewEvent = createPageViewEvent(
+        pageRenderId,
+        serverContext,
+        isApiPath,
+        userContext,
+        anonId
+      );
+      const { clientActions, completion } = dispatchEvent(pageViewEvent, ctx);
+      const actions = await clientActions;
+      scripts = actions.items.filter(
+        (i) => i.type === "script-template"
+      );
+      (0, import_server.after)(() => completion);
+    }
+    (0, import_server_component_context.serializeServerComponentContext)(response, {
+      pageRenderId,
+      pathname: request.nextUrl.pathname,
+      search: request.nextUrl.search,
+      scripts,
+      templates
+    });
+    return response;
+  };
+}
+function createPageViewEvent(pageRenderId, serverContext, isApiPath, userContext, anonymousUserId) {
+  const eventType = isApiPath ? "apiCall" : "pageView";
+  return {
+    collectedAt: serverContext.collectedAt.toISOString(),
+    eventId: pageRenderId,
+    type: eventType,
+    anonymousUserId,
+    serverContext,
+    userContext,
+    properties: {}
+  };
+}
+async function getUserContext(config, ctx) {
+  if (!config.callbacks.getUser) return void 0;
+  try {
+    return await config.callbacks.getUser(ctx) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function handleEventPost(request, config, dispatchEvent, updateEvent) {
+  const pageRenderId = request.headers.get(import_server_component_context.headers.pageRenderId);
+  if (!pageRenderId) {
+    return Response.json({ error: "Missing page render ID" }, { status: 400 });
+  }
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+  const { type, payload } = body;
+  const ctx = createRequestContext(request);
+  const serverContext = (0, import_uitils.createServerContext)(request);
+  const userContext = await getUserContext(config, ctx);
+  const { anonId: anonymousUserId } = await (0, import_anonymous_user.resolveAnonymousUser)({ ctx, serverContext, config });
+  if (type === "client-init") {
+    const clientContext = payload;
+    if (clientContext?.path) {
+      serverContext.path = clientContext.path;
+    }
+    if (config.pageViewMode === "client-init") {
+      const event = {
+        eventId: pageRenderId,
+        type: "pageView",
+        collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        anonymousUserId,
+        serverContext,
+        clientContext,
+        userContext,
+        properties: {}
+      };
+      const { clientActions, completion } = dispatchEvent(event, ctx);
+      const actions = await clientActions;
+      (0, import_server.after)(() => completion);
+      const scripts = actions.items.filter((i) => i.type === "script-template");
+      return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
+    } else {
+      (0, import_server.after)(() => updateEvent(pageRenderId, { clientContext, userContext, anonymousUserId }, ctx));
+      return Response.json({ ok: true });
+    }
+  } else if (type === "client-event") {
+    const clientContext = payload.clientContext || void 0;
+    if (clientContext?.path) {
+      serverContext.path = clientContext.path;
+    }
+    const event = {
+      eventId: (0, import_uitils.generateId)(),
+      parentEventId: pageRenderId,
+      type: payload.name || type,
+      collectedAt: payload.collectedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousUserId,
+      serverContext,
+      clientContext,
+      userContext,
+      properties: payload.props || {}
+    };
+    const { clientActions, completion } = dispatchEvent(event, ctx);
+    const actions = await clientActions;
+    (0, import_server.after)(() => completion);
+    const scripts = actions.items.filter((i) => i.type === "script-template");
+    return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
+  }
+  return Response.json({ ok: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNextlyticsMiddleware
+});

package/dist/middleware.d.mts

@@ -0,0 +1,10 @@
+import { NextMiddleware } from 'next/server';
+import { NextlyticsEvent, RequestContext, DispatchResult } from './types.mjs';
+import { NextlyticsConfigWithDefaults } from './config-helpers.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+
+type DispatchEvent = (event: NextlyticsEvent, ctx: RequestContext) => DispatchResult;
+type UpdateEvent = (eventId: string, patch: Partial<NextlyticsEvent>, ctx: RequestContext) => Promise<void>;
+declare function createNextlyticsMiddleware(config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent): NextMiddleware;
+
+export { createNextlyticsMiddleware };

package/dist/middleware.d.ts

@@ -0,0 +1,10 @@
+import { NextMiddleware } from 'next/server';
+import { NextlyticsEvent, RequestContext, DispatchResult } from './types.js';
+import { NextlyticsConfigWithDefaults } from './config-helpers.js';
+import 'next/dist/server/web/spec-extension/cookies';
+
+type DispatchEvent = (event: NextlyticsEvent, ctx: RequestContext) => DispatchResult;
+type UpdateEvent = (eventId: string, patch: Partial<NextlyticsEvent>, ctx: RequestContext) => Promise<void>;
+declare function createNextlyticsMiddleware(config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent): NextMiddleware;
+
+export { createNextlyticsMiddleware };

package/dist/middleware.js

@@ -0,0 +1,183 @@
+import { NextResponse, after } from "next/server";
+import {
+  headers as analyticsHeaders,
+  serializeServerComponentContext
+} from "./server-component-context";
+import { generateId, getRequestInfo, createServerContext } from "./uitils";
+import { resolveAnonymousUser } from "./anonymous-user";
+function resolveBackends(config, ctx) {
+  const backends = config.backends || [];
+  return backends.map((backend) => typeof backend === "function" ? backend(ctx) : backend).filter((b) => b !== null);
+}
+function collectTemplates(backends) {
+  const templates = {};
+  for (const backend of backends) {
+    if (backend.getClientSideTemplates) {
+      Object.assign(templates, backend.getClientSideTemplates());
+    }
+  }
+  return templates;
+}
+function createRequestContext(request) {
+  return {
+    headers: request.headers,
+    cookies: request.cookies
+  };
+}
+function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
+  const { eventEndpoint } = config;
+  return async (request) => {
+    const pathname = request.nextUrl.pathname;
+    const reqInfo = getRequestInfo(request);
+    if (pathname === eventEndpoint) {
+      if (request.method === "POST") {
+        return handleEventPost(request, config, dispatchEvent, updateEvent);
+      }
+      return Response.json({ error: "Method not allowed" }, { status: 405 });
+    }
+    if (reqInfo.isNextjsInternal || reqInfo.isPrefetch || reqInfo.isStaticFile) {
+      return NextResponse.next();
+    }
+    const pageRenderId = generateId();
+    const serverContext = createServerContext(request);
+    const response = NextResponse.next();
+    const ctx = createRequestContext(request);
+    const { anonId } = await resolveAnonymousUser({ ctx, serverContext, config, response });
+    const backends = resolveBackends(config, ctx);
+    const templates = collectTemplates(backends);
+    let scripts = [];
+    if (config.pageViewMode !== "client-init") {
+      if (config.excludePaths?.(pathname)) {
+        serializeServerComponentContext(response, {
+          pageRenderId,
+          pathname: request.nextUrl.pathname,
+          search: request.nextUrl.search,
+          scripts,
+          templates
+        });
+        return response;
+      }
+      const isApiPath = config.isApiPath(pathname);
+      if (isApiPath && config.excludeApiCalls) {
+        serializeServerComponentContext(response, {
+          pageRenderId,
+          pathname: request.nextUrl.pathname,
+          search: request.nextUrl.search,
+          scripts,
+          templates
+        });
+        return response;
+      }
+      const userContext = await getUserContext(config, ctx);
+      const pageViewEvent = createPageViewEvent(
+        pageRenderId,
+        serverContext,
+        isApiPath,
+        userContext,
+        anonId
+      );
+      const { clientActions, completion } = dispatchEvent(pageViewEvent, ctx);
+      const actions = await clientActions;
+      scripts = actions.items.filter(
+        (i) => i.type === "script-template"
+      );
+      after(() => completion);
+    }
+    serializeServerComponentContext(response, {
+      pageRenderId,
+      pathname: request.nextUrl.pathname,
+      search: request.nextUrl.search,
+      scripts,
+      templates
+    });
+    return response;
+  };
+}
+function createPageViewEvent(pageRenderId, serverContext, isApiPath, userContext, anonymousUserId) {
+  const eventType = isApiPath ? "apiCall" : "pageView";
+  return {
+    collectedAt: serverContext.collectedAt.toISOString(),
+    eventId: pageRenderId,
+    type: eventType,
+    anonymousUserId,
+    serverContext,
+    userContext,
+    properties: {}
+  };
+}
+async function getUserContext(config, ctx) {
+  if (!config.callbacks.getUser) return void 0;
+  try {
+    return await config.callbacks.getUser(ctx) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function handleEventPost(request, config, dispatchEvent, updateEvent) {
+  const pageRenderId = request.headers.get(analyticsHeaders.pageRenderId);
+  if (!pageRenderId) {
+    return Response.json({ error: "Missing page render ID" }, { status: 400 });
+  }
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+  const { type, payload } = body;
+  const ctx = createRequestContext(request);
+  const serverContext = createServerContext(request);
+  const userContext = await getUserContext(config, ctx);
+  const { anonId: anonymousUserId } = await resolveAnonymousUser({ ctx, serverContext, config });
+  if (type === "client-init") {
+    const clientContext = payload;
+    if (clientContext?.path) {
+      serverContext.path = clientContext.path;
+    }
+    if (config.pageViewMode === "client-init") {
+      const event = {
+        eventId: pageRenderId,
+        type: "pageView",
+        collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        anonymousUserId,
+        serverContext,
+        clientContext,
+        userContext,
+        properties: {}
+      };
+      const { clientActions, completion } = dispatchEvent(event, ctx);
+      const actions = await clientActions;
+      after(() => completion);
+      const scripts = actions.items.filter((i) => i.type === "script-template");
+      return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
+    } else {
+      after(() => updateEvent(pageRenderId, { clientContext, userContext, anonymousUserId }, ctx));
+      return Response.json({ ok: true });
+    }
+  } else if (type === "client-event") {
+    const clientContext = payload.clientContext || void 0;
+    if (clientContext?.path) {
+      serverContext.path = clientContext.path;
+    }
+    const event = {
+      eventId: generateId(),
+      parentEventId: pageRenderId,
+      type: payload.name || type,
+      collectedAt: payload.collectedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousUserId,
+      serverContext,
+      clientContext,
+      userContext,
+      properties: payload.props || {}
+    };
+    const { clientActions, completion } = dispatchEvent(event, ctx);
+    const actions = await clientActions;
+    after(() => completion);
+    const scripts = actions.items.filter((i) => i.type === "script-template");
+    return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
+  }
+  return Response.json({ ok: true });
+}
+export {
+  createNextlyticsMiddleware
+};

package/dist/pages-router.cjs

@@ -0,0 +1,45 @@
+"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 pages_router_exports = {};
+__export(pages_router_exports, {
+  getNextlyticsProps: () => getNextlyticsProps
+});
+module.exports = __toCommonJS(pages_router_exports);
+var import_server_component_context = require("./server-component-context");
+function getNextlyticsProps(ctx) {
+  const headersList = new Headers();
+  for (const [key, value] of Object.entries(ctx.req.headers)) {
+    if (value) {
+      headersList.set(key, Array.isArray(value) ? value[0] : value);
+    }
+  }
+  const context = (0, import_server_component_context.restoreServerComponentContext)(headersList);
+  if (!context) {
+    return { requestId: "" };
+  }
+  return {
+    requestId: context.pageRenderId,
+    scripts: context.scripts,
+    templates: context.templates
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNextlyticsProps
+});

package/dist/pages-router.d.mts

@@ -0,0 +1,45 @@
+import { NextlyticsContext } from './client.mjs';
+import 'react/jsx-runtime';
+import 'react';
+import './types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type ContextWithHeaders = {
+    req: {
+        headers: Record<string, string | string[] | undefined>;
+    };
+};
+/**
+ * Extract Nextlytics context from Pages Router context (getServerSideProps or getInitialProps).
+ * Use this in _app.tsx with getInitialProps to pass context to NextlyticsClient.
+ *
+ * @example
+ * ```tsx
+ * // pages/_app.tsx
+ * import type { AppContext, AppProps } from 'next/app'
+ * import { NextlyticsClient, getNextlyticsProps, type NextlyticsContext } from '@nextlytics/core'
+ *
+ * type MyAppProps = AppProps & { nextlyticsCtx: NextlyticsContext }
+ *
+ * function MyApp({ Component, pageProps, nextlyticsCtx }: MyAppProps) {
+ *   return (
+ *     <NextlyticsClient ctx={nextlyticsCtx}>
+ *       <Component {...pageProps} />
+ *     </NextlyticsClient>
+ *   )
+ * }
+ *
+ * MyApp.getInitialProps = async (appContext: AppContext) => {
+ *   return {
+ *     pageProps: appContext.Component.getInitialProps
+ *       ? await appContext.Component.getInitialProps(appContext.ctx)
+ *       : {},
+ *     nextlyticsCtx: getNextlyticsProps(appContext.ctx),
+ *   }
+ * }
+ * ```
+ */
+declare function getNextlyticsProps(ctx: ContextWithHeaders): NextlyticsContext;
+
+export { getNextlyticsProps };

package/dist/pages-router.d.ts

@@ -0,0 +1,45 @@
+import { NextlyticsContext } from './client.js';
+import 'react/jsx-runtime';
+import 'react';
+import './types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type ContextWithHeaders = {
+    req: {
+        headers: Record<string, string | string[] | undefined>;
+    };
+};
+/**
+ * Extract Nextlytics context from Pages Router context (getServerSideProps or getInitialProps).
+ * Use this in _app.tsx with getInitialProps to pass context to NextlyticsClient.
+ *
+ * @example
+ * ```tsx
+ * // pages/_app.tsx
+ * import type { AppContext, AppProps } from 'next/app'
+ * import { NextlyticsClient, getNextlyticsProps, type NextlyticsContext } from '@nextlytics/core'
+ *
+ * type MyAppProps = AppProps & { nextlyticsCtx: NextlyticsContext }
+ *
+ * function MyApp({ Component, pageProps, nextlyticsCtx }: MyAppProps) {
+ *   return (
+ *     <NextlyticsClient ctx={nextlyticsCtx}>
+ *       <Component {...pageProps} />
+ *     </NextlyticsClient>
+ *   )
+ * }
+ *
+ * MyApp.getInitialProps = async (appContext: AppContext) => {
+ *   return {
+ *     pageProps: appContext.Component.getInitialProps
+ *       ? await appContext.Component.getInitialProps(appContext.ctx)
+ *       : {},
+ *     nextlyticsCtx: getNextlyticsProps(appContext.ctx),
+ *   }
+ * }
+ * ```
+ */
+declare function getNextlyticsProps(ctx: ContextWithHeaders): NextlyticsContext;
+
+export { getNextlyticsProps };

package/dist/pages-router.js

@@ -0,0 +1,21 @@
+import { restoreServerComponentContext } from "./server-component-context";
+function getNextlyticsProps(ctx) {
+  const headersList = new Headers();
+  for (const [key, value] of Object.entries(ctx.req.headers)) {
+    if (value) {
+      headersList.set(key, Array.isArray(value) ? value[0] : value);
+    }
+  }
+  const context = restoreServerComponentContext(headersList);
+  if (!context) {
+    return { requestId: "" };
+  }
+  return {
+    requestId: context.pageRenderId,
+    scripts: context.scripts,
+    templates: context.templates
+  };
+}
+export {
+  getNextlyticsProps
+};

package/dist/plugins/vercel-geo.cjs

@@ -0,0 +1,60 @@
+"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 vercel_geo_exports = {};
+__export(vercel_geo_exports, {
+  vercelGeoPlugin: () => vercelGeoPlugin
+});
+module.exports = __toCommonJS(vercel_geo_exports);
+const VERCEL_GEO_HEADERS = {
+  "x-vercel-ip-country": "country",
+  "x-vercel-ip-country-region": "region",
+  "x-vercel-ip-city": "city",
+  "x-vercel-ip-latitude": "latitude",
+  "x-vercel-ip-longitude": "longitude",
+  "x-vercel-ip-timezone": "timezone"
+};
+function vercelGeoPlugin(options) {
+  const geoPropertyName = options?.geoPropertyName ?? "geo";
+  return {
+    async onDispatch(event) {
+      const headers = event.serverContext.requestHeaders;
+      const geo = {};
+      for (const [header, prop] of Object.entries(VERCEL_GEO_HEADERS)) {
+        const value = headers[header];
+        if (value) {
+          if (prop === "latitude" || prop === "longitude") {
+            const num = parseFloat(value);
+            if (!isNaN(num)) {
+              geo[prop] = num;
+            }
+          } else {
+            geo[prop] = value;
+          }
+        }
+      }
+      if (Object.keys(geo).length > 0) {
+        event.properties[geoPropertyName] = geo;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  vercelGeoPlugin
+});

package/dist/plugins/vercel-geo.d.mts

@@ -0,0 +1,25 @@
+import { NextlyticsPlugin } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type VercelGeoPluginOptions = {
+    /** Property name to store geo data under. Default: "geo" */
+    geoPropertyName?: string;
+};
+/**
+ * Plugin that extracts Vercel geo headers and adds them to event properties.
+ * Only works when deployed to Vercel.
+ *
+ * @example
+ * ```ts
+ * import { vercelGeoPlugin } from "@nextlytics/core/plugins/vercel-geo";
+ *
+ * export const { middleware, handlers } = Nextlytics({
+ *   plugins: [vercelGeoPlugin()],
+ *   // ...
+ * });
+ * ```
+ */
+declare function vercelGeoPlugin(options?: VercelGeoPluginOptions): NextlyticsPlugin;
+
+export { type VercelGeoPluginOptions, vercelGeoPlugin };