@levo-so/next-middleware 0.1.97 → 0.1.102

package/dist/geoIp.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GeoIP header extractor.
+ *
+ * Pulls visitor country + language from HTTP headers across CDN providers
+ * (Cloudflare, Vercel, AWS CloudFront, Azure, BunnyCDN), nginx-ingress, and
+ * Traefik GeoIP2. Only surfaces `bestCountry` + `languageData` — the helpers
+ * that were historically exported (client IPs, provider-specific getters,
+ * raw header maps) are no longer used by any consumer.
+ */
+export interface ICountryInfo {
+    countryCode: string;
+    city?: string;
+    region?: string;
+    latitude?: string;
+    longitude?: string;
+    source: string;
+}
+export interface ILanguageInfo {
+    locale: string;
+    language: string;
+    region?: string;
+    quality: number;
+}
+export interface IParsedLanguageData {
+    languages: ILanguageInfo[];
+    primaryLanguage: string;
+    inferredRegions: string[];
+}
+/**
+ * Main entry: extract visitor country + language preferences.
+ * Accepts any header carrier — normalization is internal.
+ */
+export declare const extractGeoAndLanguageData: (headers: Record<string, string | string[]> | Headers | null | undefined) => {
+    bestCountry: ICountryInfo | null;
+    languageData: IParsedLanguageData;
+};
+//# sourceMappingURL=geoIp.d.ts.map

package/dist/geoIp.js

@@ -0,0 +1,129 @@
+/**
+ * GeoIP header extractor.
+ *
+ * Pulls visitor country + language from HTTP headers across CDN providers
+ * (Cloudflare, Vercel, AWS CloudFront, Azure, BunnyCDN), nginx-ingress, and
+ * Traefik GeoIP2. Only surfaces `bestCountry` + `languageData` — the helpers
+ * that were historically exported (client IPs, provider-specific getters,
+ * raw header maps) are no longer used by any consumer.
+ */
+const safeDecode = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};
+/** Best country info from CDN (preferred) or nginx/traefik (fallback). */
+const extractCountry = (headers) => {
+    // Cloudflare — "XX" is Cloudflare's "unknown" sentinel
+    const cf = headers["cf-ipcountry"];
+    if (cf && cf !== "XX")
+        return { countryCode: cf, source: "Cloudflare CDN" };
+    // Vercel Edge — city is URL-encoded (e.g. `San%20Francisco`)
+    const vercel = headers["x-vercel-ip-country"];
+    if (vercel) {
+        const rawCity = headers["x-vercel-ip-city"];
+        return {
+            countryCode: vercel,
+            city: rawCity ? safeDecode(rawCity) : undefined,
+            region: headers["x-vercel-ip-country-region"],
+            latitude: headers["x-vercel-ip-latitude"],
+            longitude: headers["x-vercel-ip-longitude"],
+            source: "Vercel Edge",
+        };
+    }
+    const aws = headers["cloudfront-viewer-country"];
+    if (aws)
+        return { countryCode: aws, source: "AWS CloudFront" };
+    const azure = headers["x-azure-country"];
+    if (azure)
+        return { countryCode: azure, source: "Azure CDN" };
+    const bunny = headers["x-edge-country"];
+    if (bunny)
+        return { countryCode: bunny, source: "BunnyCDN" };
+    const generic = headers["x-client-country"] || headers["x-forwarded-country"] || headers["x-country"];
+    if (generic)
+        return { countryCode: generic, source: "Generic CDN" };
+    // Infrastructure fallbacks
+    const nginx = headers["x-country-code"];
+    if (nginx) {
+        return {
+            countryCode: nginx,
+            city: headers["x-city"],
+            latitude: headers["x-latitude"],
+            longitude: headers["x-longitude"],
+            source: "nginx-ingress",
+        };
+    }
+    const traefik = headers["x-geoip2-country"];
+    if (traefik) {
+        return {
+            countryCode: traefik,
+            city: headers["x-geoip2-city"],
+            region: headers["x-geoip2-region"],
+            source: "traefik-geoip2",
+        };
+    }
+    return null;
+};
+/** Parse Accept-Language into quality-sorted list + derived regions. */
+const parseAcceptLanguage = (acceptLanguage) => {
+    if (!acceptLanguage) {
+        return { languages: [], primaryLanguage: "unknown", inferredRegions: [] };
+    }
+    const languages = acceptLanguage
+        .split(",")
+        .map((lang) => {
+        const [locale, quality] = lang.trim().split(";q=");
+        const [language, region] = (locale || "").split("-");
+        return {
+            locale: locale?.trim() || "",
+            language: language?.trim() || "",
+            region: region?.trim().toUpperCase(),
+            quality: quality ? parseFloat(quality) : 1.0,
+        };
+    })
+        .filter((l) => l.locale)
+        .sort((a, b) => b.quality - a.quality);
+    const inferredRegions = languages
+        .map((l) => l.region)
+        .filter((r) => Boolean(r))
+        .filter((r, i, arr) => arr.indexOf(r) === i);
+    return {
+        languages,
+        primaryLanguage: languages[0]?.locale || "unknown",
+        inferredRegions,
+    };
+};
+/**
+ * Normalize any header carrier (Fetch `Headers`, Node `req.headers`, plain
+ * object) into a lowercase-keyed map.
+ */
+const headersToObject = (headers) => {
+    if (!headers)
+        return {};
+    if (typeof headers.entries === "function") {
+        const obj = {};
+        for (const [k, v] of headers.entries())
+            obj[k.toLowerCase()] = v;
+        return obj;
+    }
+    const obj = {};
+    for (const [k, v] of Object.entries(headers)) {
+        obj[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+    }
+    return obj;
+};
+/**
+ * Main entry: extract visitor country + language preferences.
+ * Accepts any header carrier — normalization is internal.
+ */
+export const extractGeoAndLanguageData = (headers) => {
+    const normalized = headersToObject(headers);
+    return {
+        bestCountry: extractCountry(normalized),
+        languageData: parseAcceptLanguage(normalized["accept-language"] || ""),
+    };
+};

package/dist/index.d.ts

@@ -16,6 +16,8 @@ declare function middleware(request: NextRequest, options?: {
 declare const levoConfig: {
     matcher: string[];
 };
+export * from "./geoIp";
+export * from "./params";
 export default middleware;
-export { middleware, levoConfig };
+export { levoConfig, middleware };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -82,5 +82,7 @@ const levoConfig = {
         "/(.*sitemap.*\\.xml)",
     ],
 };
+export * from "./geoIp";
+export * from "./params";
 export default middleware;
-export { middleware, levoConfig };
+export { levoConfig, middleware };

package/dist/params.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helpers for reading Next.js route `params` produced by the proxy's
+ * `/visitor:{...json}/...` rewrite.
+ */
+export interface IParsedRouteParams {
+    slug: string[];
+    visitorParams: Record<string, unknown>;
+}
+/** Parse a `visitor:{...}` segment back into its JSON payload. */
+export declare const parseVisitorParam: (visitor: string | undefined) => Record<string, unknown>;
+/**
+ * Pull `visitorParams` + clean `slug` out of a Next.js catch-all `params`.
+ * If the first slug segment is a `visitor:{...}` prefix, it is stripped and
+ * decoded; otherwise `visitorParams` falls back to `{}`.
+ */
+export declare const parseParams: (params: Record<string, string | string[] | undefined> | undefined) => IParsedRouteParams;
+//# sourceMappingURL=params.d.ts.map

package/dist/params.js

@@ -0,0 +1,28 @@
+/**
+ * Helpers for reading Next.js route `params` produced by the proxy's
+ * `/visitor:{...json}/...` rewrite.
+ */
+/** Parse a `visitor:{...}` segment back into its JSON payload. */
+export const parseVisitorParam = (visitor) => {
+    if (typeof visitor !== "string")
+        return {};
+    try {
+        return JSON.parse(visitor.replace(/^visitor:/, ""));
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Pull `visitorParams` + clean `slug` out of a Next.js catch-all `params`.
+ * If the first slug segment is a `visitor:{...}` prefix, it is stripped and
+ * decoded; otherwise `visitorParams` falls back to `{}`.
+ */
+export const parseParams = (params) => {
+    const rawSlug = Array.isArray(params?.slug) ? params.slug : [];
+    const [first, ...rest] = rawSlug;
+    if (typeof first === "string" && first.startsWith("visitor:")) {
+        return { slug: rest, visitorParams: parseVisitorParam(first) };
+    }
+    return { slug: rawSlug, visitorParams: {} };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levo-so/next-middleware",
-  "version": "0.1.97",
+  "version": "0.1.102",
   "author": "Levo Engineering <devs@theinternetfolks.com>",
   "description": "Next middleware to add a proxy for levo integration in apps",
   "type": "module",
@@ -20,7 +20,7 @@
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "babel-plugin-react-compiler": "19.1.0-rc.3",
-    "next": "16.2.1",
+    "next": "16.2.3",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "@levo/ts-config": "0.0.0"