@netloc8/nextjs 0.1.0

package/README.md

@@ -0,0 +1,107 @@
+# @netloc8/nextjs
+
+Next.js integration for the NetLoc8 geolocation SDK. Adds a proxy for
+server-side IP resolution and helper functions for reading geo data in
+Server Components, Route Handlers, and Server Actions. Re-exports all
+React bindings (`NetLoc8Provider`, `useGeo`, `GeoGate`).
+
+## Install
+
+```bash
+bun add @netloc8/nextjs
+```
+
+**Peer dependencies:** `next >= 16`, `react >= 19`
+
+## Quick Start
+
+### 1. Set up the proxy
+
+Create `proxy.ts` in your Next.js app root:
+
+```typescript
+import { createProxy } from '@netloc8/nextjs/proxy';
+
+export default createProxy();
+```
+
+### 2. Read geo data in Server Components
+
+```typescript
+import { getGeo } from '@netloc8/nextjs/server';
+
+export default async function Page() {
+    const geo = await getGeo();
+    return <p>Hello from {geo.city}, {geo.country}</p>;
+}
+```
+
+### 3. Read geo data in Client Components
+
+Wrap your layout with `<NetLoc8Provider>`:
+
+```tsx
+import { getGeo } from '@netloc8/nextjs/server';
+import { NetLoc8Provider } from '@netloc8/nextjs';
+
+export default async function RootLayout( { children } ) {
+    const geo = await getGeo();
+
+    return (
+        <NetLoc8Provider initialGeo={geo}>
+            {children}
+        </NetLoc8Provider>
+    );
+}
+```
+
+Then use the hook in any client component:
+
+```tsx
+'use client';
+import { useGeo } from '@netloc8/nextjs';
+
+export function LocationBanner() {
+    const geo = useGeo();
+    return <p>Timezone: {geo.timezone}</p>;
+}
+```
+
+### 4. Conditional rendering with GeoGate
+
+```tsx
+import { GeoGate } from '@netloc8/nextjs';
+
+<GeoGate eu={true}>
+    <CookieConsentBanner />
+</GeoGate>
+
+<GeoGate country={['US', 'CA']} not fallback={<p>Not available in your region</p>}>
+    <SpecialOffer />
+</GeoGate>
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `NETLOC8_API_KEY` | Yes | Secret API key (`sk_...`) for the proxy |
+| `NETLOC8_API_URL` | No | API base URL (defaults to `https://netloc8.com`) |
+| `NETLOC8_TEST_IP` | No | Override IP in development |
+
+## Exports
+
+| Subpath | Export | Description |
+|---------|--------|-------------|
+| `@netloc8/nextjs/proxy` | `createProxy` | Create the proxy function for `proxy.ts` |
+| `@netloc8/nextjs/proxy` | `withGeoRedirect` | Geo-based locale redirect handler |
+| `@netloc8/nextjs/server` | `getGeo` | Read geo data in server contexts |
+| `@netloc8/nextjs/server` | `getTimezone` | Shorthand for timezone only |
+| `@netloc8/nextjs` | `NetLoc8Provider` | Re-exported from `@netloc8/react` |
+| `@netloc8/nextjs` | `useGeo` | Re-exported from `@netloc8/react` |
+| `@netloc8/nextjs` | `GeoGate` | Re-exported from `@netloc8/react` |
+| `@netloc8/nextjs` | `GeoContext` | Re-exported from `@netloc8/react` |
+
+## License
+
+[Elastic License 2.0 (ELv2)](../../LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+
+import { GeoContext, GeoGate, NetLoc8Provider, useGeo } from "@netloc8/react";
+export { GeoContext, GeoGate, NetLoc8Provider, useGeo };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+"use client";
+import { GeoContext, GeoGate, NetLoc8Provider, useGeo } from "@netloc8/react";
+export { GeoContext, GeoGate, NetLoc8Provider, useGeo };

package/dist/proxy.d.mts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { Geo } from "@netloc8/netloc8-js";
+
+//#region src/proxy.d.ts
+interface CreateProxyOptions {
+  timeout?: number;
+  apiKey?: string;
+  apiUrl?: string;
+  testIp?: string;
+  handler?: (request: NextRequest, geo: Geo) => NextResponse | undefined | Promise<NextResponse | undefined>;
+}
+interface GeoRedirectOptions {
+  defaultLocale: string;
+  localeMap: Record<string, string>;
+  excludePaths?: string[];
+}
+/**
+* Create a Next.js 16 proxy function that resolves geolocation for every
+* matching request.
+*
+* Returns a standard proxy function that can be exported directly from the
+* user's proxy.ts / proxy.js file, or composed with other proxy logic.
+*/
+declare function createProxy(options?: CreateProxyOptions): (request: NextRequest) => Promise<NextResponse>;
+/**
+* Create a geo-redirect handler for use with createProxy.
+*/
+declare function withGeoRedirect(options: GeoRedirectOptions): (request: NextRequest, geo: Geo) => NextResponse | undefined;
+//#endregion
+export { createProxy, withGeoRedirect };
+//# sourceMappingURL=proxy.d.mts.map

package/dist/proxy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.mts","names":[],"sources":["../src/proxy.ts"],"mappings":";;;;UAmBU,kBAAA;EACN,OAAA;EACA,MAAA;EACA,MAAA;EACA,MAAA;EACA,OAAA,IACI,OAAA,EAAS,WAAA,EACT,GAAA,EAAK,GAAA,KACJ,YAAA,eAA2B,OAAA,CAAQ,YAAA;AAAA;AAAA,UAGlC,kBAAA;EACN,aAAA;EACA,SAAA,EAAW,MAAA;EACX,YAAA;AAAA;;;;;;;;iBA+CY,WAAA,CAAY,OAAA,GAAU,kBAAA,IACjC,OAAA,EAAS,WAAA,KAAgB,OAAA,CAAQ,YAAA;;;;iBA+GtB,eAAA,CACZ,OAAA,EAAS,kBAAA,IACT,OAAA,EAAS,WAAA,EAAa,GAAA,EAAK,GAAA,KAAQ,YAAA"}

package/dist/proxy.mjs

@@ -0,0 +1,132 @@
+import { NextResponse } from "next/server";
+import { COOKIE_NAME, COOKIE_OPTIONS, fetchGeo, getClientIp, getGeoFromPlatformHeaders, isPublicIp, normalizeApiResponse, parseCookie, reconcileGeo, serializeCookie } from "@netloc8/netloc8-js";
+//#region src/proxy.ts
+/**
+* Header-to-Geo field mapping for setting request headers.
+*/
+const GEO_HEADER_MAP = [
+	["ip", "x-netloc8-ip"],
+	["ipVersion", "x-netloc8-ip-version"],
+	["continent", "x-netloc8-continent"],
+	["continentName", "x-netloc8-continent-name"],
+	["country", "x-netloc8-country"],
+	["countryName", "x-netloc8-country-name"],
+	["isEU", "x-netloc8-is-eu"],
+	["region", "x-netloc8-region"],
+	["regionName", "x-netloc8-region-name"],
+	["city", "x-netloc8-city"],
+	["postalCode", "x-netloc8-postal-code"],
+	["latitude", "x-netloc8-latitude"],
+	["longitude", "x-netloc8-longitude"],
+	["timezone", "x-netloc8-timezone"],
+	["accuracyRadius", "x-netloc8-accuracy-radius"],
+	["precision", "x-netloc8-precision"],
+	["isLimited", "x-netloc8-is-limited"],
+	["limitReason", "x-netloc8-limit-reason"],
+	["timezoneFromClient", "x-netloc8-timezone-from-client"]
+];
+/**
+* Set x-netloc8-* request headers from a Geo object.
+*/
+function setGeoHeaders(requestHeaders, geo) {
+	for (const [field, header] of GEO_HEADER_MAP) {
+		const value = geo[field];
+		if (value !== void 0 && value !== null) requestHeaders.set(header, encodeURIComponent(String(value)));
+	}
+}
+/**
+* Create a Next.js 16 proxy function that resolves geolocation for every
+* matching request.
+*
+* Returns a standard proxy function that can be exported directly from the
+* user's proxy.ts / proxy.js file, or composed with other proxy logic.
+*/
+function createProxy(options) {
+	return async (request) => {
+		const apiKey = options?.apiKey ?? process.env.NETLOC8_API_KEY;
+		const apiUrl = options?.apiUrl ?? process.env.NETLOC8_API_URL;
+		const timeout = options?.timeout ?? 1500;
+		const requestHeaders = new Headers(request.headers);
+		for (const [, headerName] of GEO_HEADER_MAP) requestHeaders.delete(headerName);
+		let clientIp;
+		if (process.env.NODE_ENV !== "production") clientIp = options?.testIp ?? process.env.NETLOC8_TEST_IP;
+		if (!clientIp) clientIp = getClientIp(request.headers);
+		const cookieValue = request.cookies.get(COOKIE_NAME)?.value;
+		const cookieGeo = parseCookie(cookieValue);
+		const cookieTimezone = cookieGeo.timezoneFromClient === true && cookieGeo.ip === clientIp ? {
+			timezone: cookieGeo.timezone,
+			timezoneFromClient: cookieGeo.timezoneFromClient
+		} : void 0;
+		const platformGeo = getGeoFromPlatformHeaders(request.headers);
+		let apiGeo;
+		if (clientIp && isPublicIp(clientIp) && !platformGeo.timezone && !cookieTimezone) {
+			const raw = await fetchGeo(clientIp, {
+				apiKey,
+				apiUrl,
+				timeout,
+				clientId: `@netloc8/nextjs/0.1.0`
+			});
+			if (raw) apiGeo = normalizeApiResponse(raw, clientIp);
+		}
+		const geo = reconcileGeo({
+			cookie: cookieGeo.ip ? {
+				ip: cookieGeo.ip,
+				timezone: cookieGeo.timezone,
+				timezoneFromClient: cookieGeo.timezoneFromClient
+			} : void 0,
+			platform: platformGeo,
+			api: apiGeo,
+			ip: clientIp
+		});
+		if (cookieTimezone) {
+			geo.timezone = cookieTimezone.timezone;
+			geo.timezoneFromClient = cookieTimezone.timezoneFromClient;
+		}
+		setGeoHeaders(requestHeaders, geo);
+		let handlerResponse;
+		if (options?.handler) {
+			const sanitizedRequest = new Request(request.nextUrl.toString(), {
+				method: request.method ?? "GET",
+				headers: requestHeaders,
+				body: request.body,
+				duplex: "half"
+			});
+			handlerResponse = await options.handler(Object.assign(sanitizedRequest, {
+				nextUrl: request.nextUrl,
+				cookies: request.cookies
+			}), geo);
+		}
+		const response = handlerResponse ?? NextResponse.next({ request: { headers: requestHeaders } });
+		if (!cookieValue || cookieGeo.ip !== clientIp) response.cookies.set(COOKIE_NAME, serializeCookie(geo), {
+			path: COOKIE_OPTIONS.path,
+			httpOnly: COOKIE_OPTIONS.httpOnly,
+			secure: COOKIE_OPTIONS.secure,
+			sameSite: COOKIE_OPTIONS.sameSite,
+			maxAge: COOKIE_OPTIONS.maxAge
+		});
+		return response;
+	};
+}
+/**
+* Create a geo-redirect handler for use with createProxy.
+*/
+function withGeoRedirect(options) {
+	const { defaultLocale, localeMap, excludePaths = [] } = options;
+	const validLocales = new Set(Object.values(localeMap));
+	validLocales.add(defaultLocale);
+	return (request, geo) => {
+		const pathname = request.nextUrl.pathname;
+		for (const prefix of excludePaths) if (pathname.startsWith(prefix)) return;
+		const currentPrefix = pathname.split("/").filter(Boolean)[0];
+		if (currentPrefix && validLocales.has(currentPrefix)) return;
+		const locale = geo.country && localeMap[geo.country] || defaultLocale;
+		if (locale === defaultLocale) return;
+		const url = request.nextUrl.clone();
+		url.pathname = `/${locale}${pathname}`;
+		return NextResponse.redirect(url, 307);
+	};
+}
+//#endregion
+export { createProxy, withGeoRedirect };
+
+//# sourceMappingURL=proxy.mjs.map

package/dist/proxy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.mjs","names":[],"sources":["../src/proxy.ts"],"sourcesContent":["declare const __PKG_NAME__: string;\ndeclare const __PKG_VERSION__: string;\n\nimport type { Geo } from '@netloc8/netloc8-js';\nimport type { NextRequest } from 'next/server';\nimport { NextResponse } from 'next/server';\nimport {\n    getClientIp,\n    isPublicIp,\n    getGeoFromPlatformHeaders,\n    fetchGeo,\n    normalizeApiResponse,\n    parseCookie,\n    serializeCookie,\n    reconcileGeo,\n    COOKIE_NAME,\n    COOKIE_OPTIONS,\n} from '@netloc8/netloc8-js';\n\ninterface CreateProxyOptions {\n    timeout?: number;\n    apiKey?: string;\n    apiUrl?: string;\n    testIp?: string;\n    handler?: (\n        request: NextRequest,\n        geo: Geo\n    ) => NextResponse | undefined | Promise<NextResponse | undefined>;\n}\n\ninterface GeoRedirectOptions {\n    defaultLocale: string;\n    localeMap: Record<string, string>;\n    excludePaths?: string[];\n}\n\n/**\n * Header-to-Geo field mapping for setting request headers.\n */\nconst GEO_HEADER_MAP: Array<[keyof Geo, string]> = [\n    ['ip', 'x-netloc8-ip'],\n    ['ipVersion', 'x-netloc8-ip-version'],\n    ['continent', 'x-netloc8-continent'],\n    ['continentName', 'x-netloc8-continent-name'],\n    ['country', 'x-netloc8-country'],\n    ['countryName', 'x-netloc8-country-name'],\n    ['isEU', 'x-netloc8-is-eu'],\n    ['region', 'x-netloc8-region'],\n    ['regionName', 'x-netloc8-region-name'],\n    ['city', 'x-netloc8-city'],\n    ['postalCode', 'x-netloc8-postal-code'],\n    ['latitude', 'x-netloc8-latitude'],\n    ['longitude', 'x-netloc8-longitude'],\n    ['timezone', 'x-netloc8-timezone'],\n    ['accuracyRadius', 'x-netloc8-accuracy-radius'],\n    ['precision', 'x-netloc8-precision'],\n    ['isLimited', 'x-netloc8-is-limited'],\n    ['limitReason', 'x-netloc8-limit-reason'],\n    ['timezoneFromClient', 'x-netloc8-timezone-from-client'],\n];\n\n/**\n * Set x-netloc8-* request headers from a Geo object.\n */\nfunction setGeoHeaders(requestHeaders: Headers, geo: Geo): void {\n    for (const [field, header] of GEO_HEADER_MAP) {\n        const value = geo[field];\n        if (value !== undefined && value !== null) {\n            requestHeaders.set(header, encodeURIComponent(String(value)));\n        }\n    }\n}\n\n/**\n * Create a Next.js 16 proxy function that resolves geolocation for every\n * matching request.\n *\n * Returns a standard proxy function that can be exported directly from the\n * user's proxy.ts / proxy.js file, or composed with other proxy logic.\n */\nexport function createProxy(options?: CreateProxyOptions):\n    (request: NextRequest) => Promise<NextResponse> {\n\n    return async (request: NextRequest): Promise<NextResponse> => {\n        const apiKey = options?.apiKey ?? process.env.NETLOC8_API_KEY;\n        const apiUrl = options?.apiUrl ?? process.env.NETLOC8_API_URL;\n        const timeout = options?.timeout ?? 1500;\n\n        // Security: Remove any incoming spoofed headers\n        const requestHeaders = new Headers(request.headers);\n        for (const [, headerName] of GEO_HEADER_MAP) {\n            requestHeaders.delete(headerName);\n        }\n\n        // 1. Determine client IP\n        let clientIp: string | undefined;\n\n        if (process.env.NODE_ENV !== 'production') {\n            clientIp = options?.testIp ?? process.env.NETLOC8_TEST_IP;\n        }\n\n        if (!clientIp) {\n            clientIp = getClientIp(request.headers);\n        }\n\n        // 2. Check the cookie cache (fast path)\n        const cookieValue = request.cookies.get(COOKIE_NAME)?.value;\n        const cookieGeo = parseCookie(cookieValue);\n\n        // Cookie fast path: only trust timezone/timezoneFromClient from the\n        // client-controlled cookie. Re-resolve other geo fields to prevent\n        // spoofing of country/region/city via cookie manipulation.\n        const cookieTimezone = (\n            cookieGeo.timezoneFromClient === true &&\n            cookieGeo.ip === clientIp\n        ) ? { timezone: cookieGeo.timezone, timezoneFromClient: cookieGeo.timezoneFromClient } : undefined;\n\n        // 3. Extract platform headers (zero-cost)\n        const platformGeo = getGeoFromPlatformHeaders(request.headers);\n\n        // 4. Decide whether to call the API\n        let apiGeo: Geo | undefined;\n\n        if (clientIp && isPublicIp(clientIp) && !platformGeo.timezone && !cookieTimezone) {\n            const raw = await fetchGeo(clientIp, { apiKey, apiUrl, timeout, clientId: typeof __PKG_NAME__ !== 'undefined' ? `${__PKG_NAME__}/${__PKG_VERSION__}` : undefined });\n            if (raw) {\n                apiGeo = normalizeApiResponse(raw, clientIp);\n            }\n        }\n\n        // 5. Reconcile all sources — only pass timezone fields from cookie\n        //    to prevent client-side spoofing of location data\n        const trustedCookie = cookieGeo.ip ? {\n            ip: cookieGeo.ip,\n            timezone: cookieGeo.timezone,\n            timezoneFromClient: cookieGeo.timezoneFromClient,\n        } : undefined;\n\n        const geo = reconcileGeo({\n            cookie: trustedCookie,\n            platform: platformGeo,\n            api: apiGeo,\n            ip: clientIp,\n        });\n\n        // Apply trusted cookie timezone if available\n        if (cookieTimezone) {\n            geo.timezone = cookieTimezone.timezone;\n            geo.timezoneFromClient = cookieTimezone.timezoneFromClient;\n        }\n\n        // 6. Set request headers\n        setGeoHeaders(requestHeaders, geo);\n\n        // 7. Build the response — use sanitized headers in the handler\n        let handlerResponse: NextResponse | undefined;\n        if (options?.handler) {\n            const sanitizedRequest = new Request(request.nextUrl.toString(), {\n                method: request.method ?? 'GET',\n                headers: requestHeaders,\n                body: request.body,\n                // @ts-expect-error -- NextRequest supports duplex but TS doesn't expose it\n                duplex: 'half',\n            });\n            handlerResponse = await options.handler(\n                Object.assign(sanitizedRequest, { nextUrl: request.nextUrl, cookies: request.cookies }) as NextRequest,\n                geo\n            );\n        }\n\n        const response = handlerResponse ?? NextResponse.next({\n            request: { headers: requestHeaders },\n        });\n\n        // 8. Set/update the cookie if needed\n        if (!cookieValue || cookieGeo.ip !== clientIp) {\n            response.cookies.set(COOKIE_NAME, serializeCookie(geo), {\n                path: COOKIE_OPTIONS.path,\n                httpOnly: COOKIE_OPTIONS.httpOnly,\n                secure: COOKIE_OPTIONS.secure,\n                sameSite: COOKIE_OPTIONS.sameSite,\n                maxAge: COOKIE_OPTIONS.maxAge,\n            });\n        }\n\n        return response;\n    };\n}\n\n/**\n * Create a geo-redirect handler for use with createProxy.\n */\nexport function withGeoRedirect(\n    options: GeoRedirectOptions\n): (request: NextRequest, geo: Geo) => NextResponse | undefined {\n    const { defaultLocale, localeMap, excludePaths = [] } = options;\n    const validLocales = new Set(Object.values(localeMap));\n    validLocales.add(defaultLocale);\n\n    return (request: NextRequest, geo: Geo): NextResponse | undefined => {\n        const pathname = request.nextUrl.pathname;\n\n        // Skip excluded paths\n        for (const prefix of excludePaths) {\n            if (pathname.startsWith(prefix)) {\n                return undefined;\n            }\n        }\n\n        // Extract current locale prefix from path\n        const segments = pathname.split('/').filter(Boolean);\n        const currentPrefix = segments[0];\n\n        // If path already has a valid locale prefix, don't redirect\n        if (currentPrefix && validLocales.has(currentPrefix)) {\n            return undefined;\n        }\n\n        // Look up locale for the user's country\n        const locale = (geo.country && localeMap[geo.country]) || defaultLocale;\n\n        // If resolved locale is the default and path has no locale prefix, no redirect needed\n        if (locale === defaultLocale) {\n            return undefined;\n        }\n\n        // Redirect to locale-prefixed path\n        const url = request.nextUrl.clone();\n        url.pathname = `/${locale}${pathname}`;\n        return NextResponse.redirect(url, 307);\n    };\n}\n"],"mappings":"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"}

package/dist/server.d.mts

@@ -0,0 +1,19 @@
+import { Geo } from "@netloc8/netloc8-js";
+
+//#region src/server.d.ts
+/**
+* Get the full geolocation data for the current request.
+* Must be called from a Server Component, Route Handler, or Server Action.
+*
+* Returns the Geo object populated by the proxy. If the proxy did not run
+* (e.g. the route is excluded from the matcher), returns an empty object.
+*/
+declare function getGeo(): Promise<Geo>;
+/**
+* Get the timezone for the current request.
+* Shorthand for (await getGeo()).timezone.
+*/
+declare function getTimezone(): Promise<string | undefined>;
+//#endregion
+export { getGeo, getTimezone };
+//# sourceMappingURL=server.d.mts.map

package/dist/server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.mts","names":[],"sources":["../src/server.ts"],"mappings":";;;;;AAkCA;;;;;iBAAsB,MAAA,CAAA,GAAU,OAAA,CAAQ,GAAA;;;;;iBAwClB,WAAA,CAAA,GAAe,OAAA"}

package/dist/server.mjs

@@ -0,0 +1,141 @@
+//#region src/server.ts
+/**
+* Header-to-Geo field mapping.
+*/
+const HEADER_MAP = [
+	[
+		"x-netloc8-ip",
+		"ip",
+		"string"
+	],
+	[
+		"x-netloc8-ip-version",
+		"ipVersion",
+		"number"
+	],
+	[
+		"x-netloc8-continent",
+		"continent",
+		"string"
+	],
+	[
+		"x-netloc8-continent-name",
+		"continentName",
+		"string"
+	],
+	[
+		"x-netloc8-country",
+		"country",
+		"string"
+	],
+	[
+		"x-netloc8-country-name",
+		"countryName",
+		"string"
+	],
+	[
+		"x-netloc8-is-eu",
+		"isEU",
+		"boolean"
+	],
+	[
+		"x-netloc8-region",
+		"region",
+		"string"
+	],
+	[
+		"x-netloc8-region-name",
+		"regionName",
+		"string"
+	],
+	[
+		"x-netloc8-city",
+		"city",
+		"string"
+	],
+	[
+		"x-netloc8-postal-code",
+		"postalCode",
+		"string"
+	],
+	[
+		"x-netloc8-latitude",
+		"latitude",
+		"number"
+	],
+	[
+		"x-netloc8-longitude",
+		"longitude",
+		"number"
+	],
+	[
+		"x-netloc8-timezone",
+		"timezone",
+		"string"
+	],
+	[
+		"x-netloc8-accuracy-radius",
+		"accuracyRadius",
+		"number"
+	],
+	[
+		"x-netloc8-precision",
+		"precision",
+		"string"
+	],
+	[
+		"x-netloc8-is-limited",
+		"isLimited",
+		"boolean"
+	],
+	[
+		"x-netloc8-limit-reason",
+		"limitReason",
+		"string"
+	],
+	[
+		"x-netloc8-timezone-from-client",
+		"timezoneFromClient",
+		"boolean"
+	]
+];
+/**
+* Get the full geolocation data for the current request.
+* Must be called from a Server Component, Route Handler, or Server Action.
+*
+* Returns the Geo object populated by the proxy. If the proxy did not run
+* (e.g. the route is excluded from the matcher), returns an empty object.
+*/
+async function getGeo() {
+	try {
+		const { headers } = await import("next/headers");
+		const h = await headers();
+		const geo = {};
+		for (const [header, field, type] of HEADER_MAP) {
+			const raw = h.get(header);
+			if (raw === null) continue;
+			try {
+				const decoded = decodeURIComponent(raw);
+				if (type === "number") {
+					const num = parseFloat(decoded);
+					if (!isNaN(num)) geo[field] = num;
+				} else if (type === "boolean") geo[field] = decoded === "true";
+				else geo[field] = decoded;
+			} catch {}
+		}
+		return geo;
+	} catch {
+		return {};
+	}
+}
+/**
+* Get the timezone for the current request.
+* Shorthand for (await getGeo()).timezone.
+*/
+async function getTimezone() {
+	return (await getGeo()).timezone;
+}
+//#endregion
+export { getGeo, getTimezone };
+
+//# sourceMappingURL=server.mjs.map

package/dist/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","names":[],"sources":["../src/server.ts"],"sourcesContent":["import type { Geo } from '@netloc8/netloc8-js';\n\n/**\n * Header-to-Geo field mapping.\n */\nconst HEADER_MAP: Array<[string, keyof Geo, 'string' | 'number' | 'boolean']> = [\n    ['x-netloc8-ip', 'ip', 'string'],\n    ['x-netloc8-ip-version', 'ipVersion', 'number'],\n    ['x-netloc8-continent', 'continent', 'string'],\n    ['x-netloc8-continent-name', 'continentName', 'string'],\n    ['x-netloc8-country', 'country', 'string'],\n    ['x-netloc8-country-name', 'countryName', 'string'],\n    ['x-netloc8-is-eu', 'isEU', 'boolean'],\n    ['x-netloc8-region', 'region', 'string'],\n    ['x-netloc8-region-name', 'regionName', 'string'],\n    ['x-netloc8-city', 'city', 'string'],\n    ['x-netloc8-postal-code', 'postalCode', 'string'],\n    ['x-netloc8-latitude', 'latitude', 'number'],\n    ['x-netloc8-longitude', 'longitude', 'number'],\n    ['x-netloc8-timezone', 'timezone', 'string'],\n    ['x-netloc8-accuracy-radius', 'accuracyRadius', 'number'],\n    ['x-netloc8-precision', 'precision', 'string'],\n    ['x-netloc8-is-limited', 'isLimited', 'boolean'],\n    ['x-netloc8-limit-reason', 'limitReason', 'string'],\n    ['x-netloc8-timezone-from-client', 'timezoneFromClient', 'boolean'],\n];\n\n/**\n * Get the full geolocation data for the current request.\n * Must be called from a Server Component, Route Handler, or Server Action.\n *\n * Returns the Geo object populated by the proxy. If the proxy did not run\n * (e.g. the route is excluded from the matcher), returns an empty object.\n */\nexport async function getGeo(): Promise<Geo> {\n    try {\n        const { headers } = await import('next/headers');\n        const h = await headers();\n        const geo: Geo = {};\n\n        for (const [header, field, type] of HEADER_MAP) {\n            const raw = h.get(header);\n            if (raw === null) {\n                continue;\n            }\n\n            try {\n                const decoded = decodeURIComponent(raw);\n\n                if (type === 'number') {\n                    const num = parseFloat(decoded);\n                    if (!isNaN(num)) {\n                        (geo as Record<string, unknown>)[field] = num;\n                    }\n                } else if (type === 'boolean') {\n                    (geo as Record<string, unknown>)[field] = decoded === 'true';\n                } else {\n                    (geo as Record<string, unknown>)[field] = decoded;\n                }\n            } catch {\n                // Skip this header if decodeURIComponent throws\n            }\n        }\n\n        return geo;\n    } catch {\n        return {};\n    }\n}\n\n/**\n * Get the timezone for the current request.\n * Shorthand for (await getGeo()).timezone.\n */\nexport async function getTimezone(): Promise<string | undefined> {\n    const geo = await getGeo();\n    return geo.timezone;\n}\n"],"mappings":";;;;AAKA,MAAM,aAA0E;CAC5E;EAAC;EAAgB;EAAM;EAAS;CAChC;EAAC;EAAwB;EAAa;EAAS;CAC/C;EAAC;EAAuB;EAAa;EAAS;CAC9C;EAAC;EAA4B;EAAiB;EAAS;CACvD;EAAC;EAAqB;EAAW;EAAS;CAC1C;EAAC;EAA0B;EAAe;EAAS;CACnD;EAAC;EAAmB;EAAQ;EAAU;CACtC;EAAC;EAAoB;EAAU;EAAS;CACxC;EAAC;EAAyB;EAAc;EAAS;CACjD;EAAC;EAAkB;EAAQ;EAAS;CACpC;EAAC;EAAyB;EAAc;EAAS;CACjD;EAAC;EAAsB;EAAY;EAAS;CAC5C;EAAC;EAAuB;EAAa;EAAS;CAC9C;EAAC;EAAsB;EAAY;EAAS;CAC5C;EAAC;EAA6B;EAAkB;EAAS;CACzD;EAAC;EAAuB;EAAa;EAAS;CAC9C;EAAC;EAAwB;EAAa;EAAU;CAChD;EAAC;EAA0B;EAAe;EAAS;CACnD;EAAC;EAAkC;EAAsB;EAAU;CACtE;;;;;;;;AASD,eAAsB,SAAuB;AACzC,KAAI;EACA,MAAM,EAAE,YAAY,MAAM,OAAO;EACjC,MAAM,IAAI,MAAM,SAAS;EACzB,MAAM,MAAW,EAAE;AAEnB,OAAK,MAAM,CAAC,QAAQ,OAAO,SAAS,YAAY;GAC5C,MAAM,MAAM,EAAE,IAAI,OAAO;AACzB,OAAI,QAAQ,KACR;AAGJ,OAAI;IACA,MAAM,UAAU,mBAAmB,IAAI;AAEvC,QAAI,SAAS,UAAU;KACnB,MAAM,MAAM,WAAW,QAAQ;AAC/B,SAAI,CAAC,MAAM,IAAI,CACV,KAAgC,SAAS;eAEvC,SAAS,UACf,KAAgC,SAAS,YAAY;QAErD,KAAgC,SAAS;WAE1C;;AAKZ,SAAO;SACH;AACJ,SAAO,EAAE;;;;;;;AAQjB,eAAsB,cAA2C;AAE7D,SADY,MAAM,QAAQ,EACf"}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@netloc8/nextjs",
+    "version": "0.1.0",
+    "type": "module",
+    "license": "Elastic-2.0",
+    "exports": {
+        ".": {
+            "bun": "./src/index.ts",
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.mts"
+        },
+        "./proxy": {
+            "bun": "./src/proxy.ts",
+            "import": "./dist/proxy.mjs",
+            "types": "./dist/proxy.d.mts"
+        },
+        "./server": {
+            "bun": "./src/server.ts",
+            "import": "./dist/server.mjs",
+            "types": "./dist/server.d.mts"
+        }
+    },
+    "files": [
+        "dist/",
+        "proxy/",
+        "server/"
+    ],
+    "scripts": {
+        "build": "tsdown",
+        "clean": "rm -rf dist",
+        "test": "bun test src/"
+    },
+    "peerDependencies": {
+        "next": ">=16.0.0",
+        "react": ">=19.0.0"
+    },
+    "dependencies": {
+        "@netloc8/netloc8-js": "0.1.0",
+        "@netloc8/react": "0.1.0"
+    }
+}

package/proxy/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "../dist/proxy.mjs",
+    "types": "../dist/proxy.d.mts"
+}

package/server/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "../dist/server.mjs",
+    "types": "../dist/server.d.mts"
+}