@better-i18n/next 0.1.0 → 0.1.3

package/README.md

@@ -1,6 +1,6 @@
 # @better-i18n/next
 
-Headless Next.js integration for Better i18n. This package owns your `next-intl` wiring, middleware/proxy, and CDN fetching.
+Next.js integration for [Better i18n](https://better-i18n.com). Handles `next-intl` wiring, middleware, and CDN-based translation fetching.
 
 ## Install
 
@@ -8,20 +8,23 @@ Headless Next.js integration for Better i18n. This package owns your `next-intl`
 npm i @better-i18n/next next-intl
 ```
 
-## Quick start
+## Quick Start
+
+### 1. Create i18n config
 
 ```ts
 // i18n.ts
 import { createI18n } from "@better-i18n/next";
 
 export const i18n = createI18n({
-  workspaceId: "ws_123",
-  projectSlug: "landing",
+  project: "your-org/your-project",  // Format: "org-slug/project-slug"
   defaultLocale: "en",
   debug: process.env.NODE_ENV !== "production",
 });
 ```
 
+### 2. Setup request config
+
 ```ts
 // app/i18n/request.ts
 import { i18n } from "./i18n";
@@ -29,25 +32,20 @@ import { i18n } from "./i18n";
 export default i18n.requestConfig;
 ```
 
+### 3. Add middleware
+
 ```ts
-// middleware.ts (Next 15.x)
+// middleware.ts
 import { i18n } from "./i18n";
 
 export default i18n.middleware;
 
 export const config = {
-  matcher: ["/", "/((?!api|_next|_vercel|.*\\..*).*)"],
+  matcher: ["/", "/((?!api|_next|_vercel|.*\\..*).*)" ],
 };
 ```
 
-```ts
-// proxy.ts (Next 16+)
-import { i18n } from "./i18n";
-
-export default i18n.proxy;
-```
-
-## Client hook
+## Client Hook
 
 ```tsx
 "use client";
@@ -56,8 +54,7 @@ import { useManifestLanguages } from "@better-i18n/next/client";
 
 export function LanguageSwitcher() {
   const { languages, isLoading, error } = useManifestLanguages({
-    workspaceId: "ws_123",
-    projectSlug: "landing",
+    project: "your-org/your-project",
     defaultLocale: "en",
   });
 
@@ -74,27 +71,33 @@ export function LanguageSwitcher() {
 }
 ```
 
-## Server helpers
+## Server Helpers
 
 ```ts
 import { getLocales, getMessages } from "@better-i18n/next/server";
 
-const locales = await getLocales({ workspaceId, projectSlug, defaultLocale });
-const messages = await getMessages({ workspaceId, projectSlug, defaultLocale }, "tr");
+const config = { project: "your-org/your-project", defaultLocale: "en" };
+
+const locales = await getLocales(config);
+const messages = await getMessages(config, "tr");
 ```
 
-## Debug logging
+## Configuration Options
 
-- `BETTER_I18N_DEBUG=1`
-- `BETTER_I18N_LOG_LEVEL=debug|info|warn|error|silent`
+| Option | Type | Description |
+|--------|------|-------------|
+| `project` | `string` | **Required.** Format: `"org-slug/project-slug"` |
+| `defaultLocale` | `string` | **Required.** Default locale code (e.g., `"en"`) |
+| `cdnBaseUrl` | `string` | CDN URL (default: `https://cdn.better-i18n.com`) |
+| `debug` | `boolean` | Enable verbose logging |
+| `localePrefix` | `"as-needed" \| "always" \| "never"` | URL prefix strategy |
 
-`debug` in config also enables verbose logs.
+## Debug Logging
 
-## Notes
-
-- Fail-fast: CDN errors throw (no local fallback).
-- For Next apps, ensure `transpilePackages: ["@better-i18n/next"]` if your bundler doesn’t compile TS in node_modules.
+Enable with environment variables:
+- `BETTER_I18N_DEBUG=1`
+- `BETTER_I18N_LOG_LEVEL=debug|info|warn|error|silent`
 
 ## License
 
-MIT
+MIT © [Better i18n](https://better-i18n.com)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-i18n/next",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Better-i18n Next.js integration",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,10 @@
       "types": "./src/middleware.ts",
       "default": "./src/middleware.ts"
     },
+    "./proxy": {
+      "types": "./src/proxy.ts",
+      "default": "./src/proxy.ts"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -52,6 +56,9 @@
   "scripts": {
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "@better-i18n/core": "workspace:*"
+  },
   "peerDependencies": {
     "next": ">=15.0.0",
     "next-intl": ">=4.0.0",
@@ -61,7 +68,7 @@
   "devDependencies": {
     "next": "^15.4.4",
     "next-intl": "^4.5.8",
-    "@repo/typescript-config": "workspace:*",
+    "@better-i18n/typescript-config": "workspace:*",
     "@types/node": "^20.0.0",
     "@types/react": "^19.0.0",
     "typescript": "~5.9.2"

package/src/client.ts

@@ -26,7 +26,7 @@ type ClientCacheEntry = {
 const clientCache = new Map<string, ClientCacheEntry>();
 
 const getCacheKey = (config: I18nConfig) =>
-  `${config.cdnBaseUrl || "https://cdn.better-i18n.com"}|${config.workspaceId}|${config.projectSlug}`;
+  `${config.cdnBaseUrl || "https://cdn.better-i18n.com"}|${config.project}`;
 
 const fetchManifestLanguages = async (
   config: I18nConfig,
@@ -62,8 +62,7 @@ export const useManifestLanguages = (
   const normalized = useMemo(
     () => normalizeConfig(config),
     [
-      config.workspaceId,
-      config.projectSlug,
+      config.project,
       config.defaultLocale,
       config.cdnBaseUrl,
       config.localePrefix,

package/src/config.ts

@@ -1,27 +1,39 @@
+import {
+  parseProject,
+  getProjectBaseUrl as coreGetProjectBaseUrl,
+  normalizeConfig as coreNormalizeConfig,
+} from "@better-i18n/core";
 import type { I18nConfig, NormalizedConfig } from "./types";
 
-const DEFAULT_CDN_BASE_URL = "https://cdn.better-i18n.com";
+// Re-export parseProject from core
+export { parseProject };
 
+/**
+ * Normalize Next.js i18n config with defaults
+ */
 export const normalizeConfig = (config: I18nConfig): NormalizedConfig => {
-  if (!config.workspaceId?.trim()) {
-    throw new Error("[better-i18n] workspaceId is required");
-  }
-  if (!config.projectSlug?.trim()) {
-    throw new Error("[better-i18n] projectSlug is required");
-  }
-  if (!config.defaultLocale?.trim()) {
-    throw new Error("[better-i18n] defaultLocale is required");
-  }
+  // Use core normalization for base config
+  const coreConfig = coreNormalizeConfig({
+    project: config.project,
+    defaultLocale: config.defaultLocale,
+    cdnBaseUrl: config.cdnBaseUrl,
+    manifestCacheTtlMs: config.manifestCacheTtlMs,
+    debug: config.debug,
+    logLevel: config.logLevel,
+    fetch: config.fetch,
+  });
 
+  // Add Next.js-specific defaults
   return {
-    ...config,
-    cdnBaseUrl: config.cdnBaseUrl?.replace(/\/$/, "") || DEFAULT_CDN_BASE_URL,
+    ...coreConfig,
     localePrefix: config.localePrefix ?? "as-needed",
-    manifestCacheTtlMs: config.manifestCacheTtlMs ?? 5 * 60 * 1000,
     manifestRevalidateSeconds: config.manifestRevalidateSeconds ?? 3600,
     messagesRevalidateSeconds: config.messagesRevalidateSeconds ?? 30,
   };
 };
 
-export const getProjectBaseUrl = (config: NormalizedConfig) =>
-  `${config.cdnBaseUrl}/${config.workspaceId}/${config.projectSlug}`;
+/**
+ * Get the project base URL on CDN
+ */
+export const getProjectBaseUrl = (config: NormalizedConfig): string =>
+  coreGetProjectBaseUrl(config);

package/src/core.ts

@@ -1,4 +1,4 @@
-import { normalizeConfig, getProjectBaseUrl } from "./config";
+import { getProjectBaseUrl, normalizeConfig } from "./config";
 import { createLogger } from "./logger";
 import { extractLanguages } from "./manifest";
 import type {
@@ -18,7 +18,7 @@ type ManifestCacheEntry = {
 const manifestCache = new Map<string, ManifestCacheEntry>();
 
 const buildCacheKey = (config: NormalizedConfig) =>
-  `${config.cdnBaseUrl}|${config.workspaceId}|${config.projectSlug}`;
+  `${config.cdnBaseUrl}|${config.project}`;
 
 const withRevalidate = (
   init: NextFetchRequestInit,

package/src/logger.ts

@@ -1,4 +1,5 @@
-import type { I18nConfig, Logger, LogLevel } from "./types";
+import type { Logger, LogLevel } from "@better-i18n/core";
+import type { I18nConfig } from "./types";
 
 const LEVEL_RANK: Record<LogLevel, number> = {
   debug: 0,

package/src/manifest.ts

@@ -1,28 +1,2 @@
-import type {
-  LanguageOption,
-  ManifestLanguage,
-  ManifestResponse,
-} from "./types";
-
-const normalizeLanguage = (language: ManifestLanguage): LanguageOption => ({
-  code: language.code,
-  name: language.name,
-  nativeName:
-    language.nativeName || language.name || language.code.toUpperCase(),
-  flagUrl: language.flagUrl ?? null,
-});
-
-export const extractLanguages = (
-  manifest: ManifestResponse,
-): LanguageOption[] => {
-  const languages = Array.isArray(manifest.languages)
-    ? manifest.languages
-    : [];
-
-  return languages
-    .filter(
-      (language): language is ManifestLanguage =>
-        !!language && typeof language.code === "string" && language.code.length > 0,
-    )
-    .map(normalizeLanguage);
-};
+// Re-export from i18n-core
+export { extractLanguages } from "@better-i18n/core";

package/src/middleware.ts

@@ -1,11 +1,18 @@
 import createMiddleware from "next-intl/middleware";
-import type { NextRequest } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
+// @ts-ignore - internal workspace dependency
+import { detectLocale, getLocales as getCDNLocales } from "@better-i18n/core";
+// @ts-ignore - internal workspace dependency
+import type { I18nMiddlewareConfig } from "@better-i18n/core";
 
 import { normalizeConfig } from "./config";
 import { createLogger } from "./logger";
 import { getLocales } from "./core";
 import type { I18nConfig } from "./types";
 
+/**
+ * Legacy Next-intl based middleware
+ */
 export const createI18nMiddleware = (config: I18nConfig) => {
   const normalized = normalizeConfig(config);
   const logger = createLogger(normalized, "middleware");
@@ -25,3 +32,75 @@ export const createI18nMiddleware = (config: I18nConfig) => {
 };
 
 export const createI18nProxy = createI18nMiddleware;
+
+/**
+ * Modern composable middleware for Better i18n
+ */
+export function createBetterI18nMiddleware(config: I18nMiddlewareConfig) {
+  const { project, defaultLocale, detection = {} } = config;
+
+  const {
+    cookie = true,
+    browserLanguage = true,
+    cookieName = "locale",
+    cookieMaxAge = 31536000,
+  } = detection;
+
+  return async (request: NextRequest): Promise<NextResponse> => {
+    // 1. Fetch available locales from CDN
+    const availableLocales = await getCDNLocales({ project });
+
+    // 2. Extract locale indicators
+    const pathLocale = request.nextUrl.pathname.split("/")[1];
+    const cookieLocale = cookie ? request.cookies.get(cookieName)?.value : null;
+    const headerLocale = browserLanguage
+      ? request.headers.get("accept-language")?.split(",")[0]?.split("-")[0]
+      : null;
+
+    // 3. Detect locale using core logic
+    const result = detectLocale({
+      project,
+      defaultLocale,
+      pathLocale,
+      cookieLocale: cookieLocale || null,
+      headerLocale,
+      availableLocales,
+    });
+
+    // 4. Create response
+    const response = NextResponse.next();
+
+    // 5. Set cookie if needed
+    if (cookie && result.shouldSetCookie) {
+      response.cookies.set(cookieName, result.locale, {
+        path: "/",
+        maxAge: cookieMaxAge,
+        sameSite: "lax",
+      });
+    }
+
+    return response;
+  };
+}
+
+/**
+ * Helper to compose multiple Next.js middleware
+ */
+export function composeMiddleware(
+  ...middlewares: Array<(req: NextRequest) => Promise<NextResponse>>
+) {
+  return async (request: NextRequest): Promise<NextResponse> => {
+    let response = NextResponse.next();
+
+    for (const middleware of middlewares) {
+      response = await middleware(request);
+
+      // Short-circuit on redirect/rewrite (status >= 300)
+      if (response.status >= 300) {
+        break;
+      }
+    }
+
+    return response;
+  };
+}

package/src/proxy.ts

@@ -0,0 +1 @@
+export { createI18nProxy } from "./middleware";

package/src/types.ts

@@ -1,68 +1,57 @@
-export type Locale = string;
+// Re-export common types from i18n-core
+export type {
+  Locale,
+  LogLevel,
+  ManifestLanguage,
+  ManifestFile,
+  ManifestResponse,
+  LanguageOption,
+  Messages,
+  Logger,
+  ParsedProject,
+} from "@better-i18n/core";
+
+import type { I18nCoreConfig, NormalizedConfig as CoreNormalizedConfig } from "@better-i18n/core";
+
+// Next.js-specific types
 
 export type LocalePrefix = "as-needed" | "always" | "never";
 
-export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
-
-export interface I18nConfig {
-  workspaceId: string;
-  projectSlug: string;
-  defaultLocale: string;
-  cdnBaseUrl?: string;
+/**
+ * Next.js i18n configuration (extends core config)
+ */
+export interface I18nConfig extends I18nCoreConfig {
+  /**
+   * URL locale prefix behavior
+   * @default "as-needed"
+   */
   localePrefix?: LocalePrefix;
-  debug?: boolean;
-  logLevel?: LogLevel;
-  manifestCacheTtlMs?: number;
+
+  /**
+   * Next.js ISR revalidation time for manifest (seconds)
+   * @default 3600
+   */
   manifestRevalidateSeconds?: number;
+
+  /**
+   * Next.js ISR revalidation time for messages (seconds)
+   * @default 30
+   */
   messagesRevalidateSeconds?: number;
-  fetch?: typeof fetch;
 }
 
-export interface NormalizedConfig extends I18nConfig {
-  cdnBaseUrl: string;
+/**
+ * Normalized Next.js config with defaults
+ */
+export interface NormalizedConfig extends CoreNormalizedConfig, Omit<I18nConfig, keyof I18nCoreConfig> {
   localePrefix: LocalePrefix;
+  manifestRevalidateSeconds: number;
+  messagesRevalidateSeconds: number;
 }
 
-export interface ManifestLanguage {
-  code: string;
-  name?: string;
-  nativeName?: string;
-  flagUrl?: string | null;
-  isSource?: boolean;
-  lastUpdated?: string | null;
-  keyCount?: number;
-}
-
-export interface ManifestFile {
-  url: string;
-  size: number;
-  lastModified: string | null;
-}
-
-export interface ManifestResponse {
-  projectSlug?: string;
-  sourceLanguage?: string;
-  languages: ManifestLanguage[];
-  files?: Record<string, ManifestFile>;
-  updatedAt?: string;
-}
-
-export interface LanguageOption {
-  code: string;
-  name?: string;
-  nativeName?: string;
-  flagUrl?: string | null;
-}
-
-export type Messages = Record<string, any>;
-
-export interface Logger {
-  debug: (...args: unknown[]) => void;
-  info: (...args: unknown[]) => void;
-  warn: (...args: unknown[]) => void;
-  error: (...args: unknown[]) => void;
-}
-
+/**
+ * Next.js fetch request init with ISR options
+ */
 export type NextFetchRequestInit = RequestInit & {
   next?: {
     revalidate?: number;