next-tongue 0.9.8 → 0.9.9

package/dist/compiler/validate/a11y.js

@@ -75,6 +75,8 @@ function hasLangHint(src) {
         /<html[^>]*\blang=["']/.test(src) ||
         /\blang=\{locale\}/.test(src) ||
         /document\.documentElement\.lang/.test(src) ||
+        /setAttribute\(\s*['"]lang['"]/.test(src) ||
+        /\bHtmlLang\b/.test(src) ||
         /\.lang\s*=/.test(src));
 }
 function hasDirHint(src) {
@@ -82,7 +84,9 @@ function hasDirHint(src) {
         /<html[^>]*\bdir=["']/.test(src) ||
         /\bdir=\{getDir\(/.test(src) ||
         /\bdir=\{.*getDir/.test(src) ||
-        /document\.documentElement\.dir/.test(src));
+        /document\.documentElement\.dir/.test(src) ||
+        /setAttribute\(\s*['"]dir['"]/.test(src) ||
+        /\bHtmlLang\b/.test(src));
 }
 async function findLocaleLayouts(cwd) {
     return findLayoutsUnder(cwd, ['app/[locale]', 'src/app/[locale]']);

package/dist/compiler/validate/catalog.d.ts

@@ -22,3 +22,8 @@ export declare function validateStale(config: ResolvedTongueConfig, cwd: string,
 }): Promise<CheckIssue[]>;
 /** Letter + single quote + letter — usually meant as prose apostrophe, not ICU quote. */
 export declare function likelyUnescapedApostrophe(icu: string): boolean;
+/**
+ * Apostrophe-in-words is common in fr/it/…; English `don't` floods CI with noise.
+ * Only hint for locales that regularly need ICU `''` in prose.
+ */
+export declare function shouldHintApostrophe(locale: string): boolean;

package/dist/compiler/validate/catalog.js

@@ -69,11 +69,12 @@ export async function validateCatalog(config, cwd, opts) {
                 });
                 continue;
             }
-            if (likelyUnescapedApostrophe(source)) {
+            if (shouldHintApostrophe(config.defaultLocale) &&
+                likelyUnescapedApostrophe(source)) {
                 issues.push({
                     check: 'icu',
                     severity: 'warn',
-                    message: `Key "${fullKey}" looks like a natural-language apostrophe (e.g. French). In ICU, double it: "l''été" → l'été`,
+                    message: `Key "${fullKey}" looks like a natural-language apostrophe. In ICU, double it: "l''été" → l'été`,
                     key: fullKey,
                     locale: config.defaultLocale,
                     file,
@@ -142,6 +143,17 @@ export async function validateCatalog(config, cwd, opts) {
                     });
                     continue;
                 }
+                if (shouldHintApostrophe(locale) &&
+                    likelyUnescapedApostrophe(resolved)) {
+                    issues.push({
+                        check: 'icu',
+                        severity: 'warn',
+                        message: `Key "${fullKey}" looks like a natural-language apostrophe. In ICU, double it: "l''été" → l'été`,
+                        key: fullKey,
+                        locale,
+                        file: localeFile,
+                    });
+                }
                 const mismatchSev = severityFor(config.strict.mismatch);
                 if (mismatchSev) {
                     const otherArgs = collectArgs(otherAst);
@@ -247,3 +259,10 @@ export function likelyUnescapedApostrophe(icu) {
     }
     return false;
 }
+/**
+ * Apostrophe-in-words is common in fr/it/…; English `don't` floods CI with noise.
+ * Only hint for locales that regularly need ICU `''` in prose.
+ */
+export function shouldHintApostrophe(locale) {
+    return /^(fr|it|ca|oc|ht|lb|rm|ga|gd|mt)(-|$)/i.test(locale);
+}

package/dist/navigation/index.d.ts

@@ -48,6 +48,7 @@ export declare function createNavigation(config: NavigationConfig): {
         refresh: () => void;
     };
     usePathname: () => string;
+    usePathnameWithoutLocale: () => string;
     getPathname: (args: {
         href: Href;
         locale: Locale;
@@ -57,3 +58,10 @@ export declare function createNavigation(config: NavigationConfig): {
         children: (options: import("./locale-switcher.js").UseLocaleSwitcherResult) => ReactNode;
     }) => import("react").JSX.Element;
 };
+/**
+ * Strip a leading locale segment from `next/navigation`'s pathname.
+ * Prefer `createNavigation(…).usePathname` / `usePathnameWithoutLocale` when
+ * you already use tongue navigation; this unbound helper is for apps that keep
+ * plain `next/link` + proxy for as-needed paths.
+ */
+export declare function usePathnameWithoutLocale(locales: readonly string[]): string;

package/dist/navigation/index.js

@@ -77,6 +77,10 @@ export function createNavigation(config) {
         const locale = useLocale();
         return toInternalPathname(stripped, locale, bound.pathnames);
     }
+    /** Same as `usePathname` when pathnames are unset — locale prefix stripped. */
+    function usePathnameWithoutLocale() {
+        return stripLocalePrefix(useNextPathname(), bound.locales);
+    }
     const { useLocaleSwitcher, LocaleSwitcher } = createLocaleSwitcher(config);
     return {
         Link,
@@ -84,8 +88,18 @@ export function createNavigation(config) {
         permanentRedirect,
         useRouter,
         usePathname,
+        usePathnameWithoutLocale,
         getPathname: (args) => resolve(args.href, args.locale),
         useLocaleSwitcher,
         LocaleSwitcher,
     };
 }
+/**
+ * Strip a leading locale segment from `next/navigation`'s pathname.
+ * Prefer `createNavigation(…).usePathname` / `usePathnameWithoutLocale` when
+ * you already use tongue navigation; this unbound helper is for apps that keep
+ * plain `next/link` + proxy for as-needed paths.
+ */
+export function usePathnameWithoutLocale(locales) {
+    return stripLocalePrefix(useNextPathname(), locales);
+}

package/dist/proxy/index.d.ts

@@ -48,6 +48,8 @@ export type CreateProxyOptions = {
     resolveLocale?: (req: TongueProxyRequest) => string | undefined | Promise<string | undefined>;
     onLocale?: (locale: string, req: TongueProxyRequest) => void;
 };
+/** Default locale cookie name (`SameSite=Lax`). Use with `requestLocale` in API routes. */
+export declare const LOCALE_COOKIE_NAME = "TONGUE_LOCALE";
 /**
  * Next.js 16 `proxy.ts` handler for locale prefix routing.
  * Returns standard `Response` objects (compatible with Next proxy/middleware).

package/dist/proxy/index.js

@@ -2,8 +2,10 @@ import { toInternalPathname } from '../navigation/pathname.js';
 import { createLocaleMatcher, } from './locale-matcher.js';
 export { createLocaleMatcher, buildLocaleMatcherTables, emitLocaleMatcherModule, localeParentChain, matchTagAgainstTables, } from './locale-matcher.js';
 export { verifyLocalePreference, signLocalePreference, timingSafeEqual, DEFAULT_PREF_COOKIE, } from '../runtime/locale-preference.js';
+/** Default locale cookie name (`SameSite=Lax`). Use with `requestLocale` in API routes. */
+export const LOCALE_COOKIE_NAME = 'TONGUE_LOCALE';
 const DEFAULT_COOKIE = {
-    name: 'TONGUE_LOCALE',
+    name: LOCALE_COOKIE_NAME,
     maxAge: 60 * 60 * 24 * 365,
     sameSite: 'lax',
     path: '/',

package/dist/server/index.d.ts

@@ -61,3 +61,5 @@ export type { Format, SanctionedUnit, SimpleUnit, DisplayNameType, } from '../ru
 export { isSanctionedUnit, SIMPLE_UNITS } from '../runtime/format.js';
 export { setLocalePreference, } from './locale-preference.js';
 export type { SetLocalePreferenceOptions, CookieStoreLike, } from './locale-preference.js';
+export { requestLocale, LOCALE_COOKIE_NAME, LOCALE_HEADER_NAME, } from './request-locale.js';
+export type { RequestLocaleOptions, RequestLocaleSource, } from './request-locale.js';

package/dist/server/index.js

@@ -56,7 +56,7 @@ export async function getT(localeOrNs, namespace) {
 async function getTWithLocale(locale, ns) {
     assertLocale(locale);
     if (!namespaceLoader) {
-        throw new TongueError('TONGUE_E_TYPES_MISSING', 'Message modules not loaded. Call ensureTongue() from `#tongue/runtime` (or wrap next.config with withTongue()).');
+        throw new TongueError('TONGUE_E_TYPES_MISSING', 'Message modules not loaded. Import ensureTongue from `#tongue/runtime` and call it once (layout/page), or wrap next.config with withTongue() and run `tongue build && next build` so `.tongue/` is fresh.');
     }
     const messages = await namespaceLoader(ns);
     return createT({
@@ -141,6 +141,7 @@ export { generateAlternates, createGenerateAlternates, } from './alternates.js';
 export { translateIssues, defaultFormatPath, } from '../runtime/translate-issues.js';
 export { isSanctionedUnit, SIMPLE_UNITS } from '../runtime/format.js';
 export { setLocalePreference, } from './locale-preference.js';
+export { requestLocale, LOCALE_COOKIE_NAME, LOCALE_HEADER_NAME, } from './request-locale.js';
 function assertLocale(locale) {
     if (runtimeLocales.length && !runtimeLocales.includes(locale)) {
         throw new TongueError('TONGUE_E_LOCALE', `Locale "${locale}" is not in configured locales [${runtimeLocales.join(', ')}]`);

package/dist/server/request-locale.d.ts

@@ -0,0 +1,27 @@
+/** Default cookie name set by `createProxy` (`SameSite=Lax`). */
+export declare const LOCALE_COOKIE_NAME = "TONGUE_LOCALE";
+/** Common header for client → API locale (wizard / fetch). */
+export declare const LOCALE_HEADER_NAME = "x-locale";
+export type RequestLocaleSource = {
+    headers: {
+        get: (name: string) => string | null;
+    };
+    cookies?: {
+        get: (name: string) => {
+            value: string;
+        } | undefined;
+    };
+};
+export type RequestLocaleOptions = {
+    locales: readonly string[];
+    defaultLocale: string;
+    /** Defaults to `TONGUE_LOCALE`. */
+    cookieName?: string;
+    /** Defaults to `x-locale`. */
+    headerName?: string;
+};
+/**
+ * Resolve locale in Route Handlers / Server Actions (no `params.locale`).
+ * Order: header → cookie → defaultLocale.
+ */
+export declare function requestLocale(req: RequestLocaleSource, opts: RequestLocaleOptions): string;

package/dist/server/request-locale.js

@@ -0,0 +1,22 @@
+import { isLocale as isLocaleValue } from '../runtime/locale.js';
+/** Default cookie name set by `createProxy` (`SameSite=Lax`). */
+export const LOCALE_COOKIE_NAME = 'TONGUE_LOCALE';
+/** Common header for client → API locale (wizard / fetch). */
+export const LOCALE_HEADER_NAME = 'x-locale';
+/**
+ * Resolve locale in Route Handlers / Server Actions (no `params.locale`).
+ * Order: header → cookie → defaultLocale.
+ */
+export function requestLocale(req, opts) {
+    const headerName = opts.headerName ?? LOCALE_HEADER_NAME;
+    const cookieName = opts.cookieName ?? LOCALE_COOKIE_NAME;
+    const fromHeader = req.headers.get(headerName)?.trim();
+    if (fromHeader && isLocaleValue(fromHeader, opts.locales)) {
+        return fromHeader;
+    }
+    const fromCookie = req.cookies?.get(cookieName)?.value?.trim();
+    if (fromCookie && isLocaleValue(fromCookie, opts.locales)) {
+        return fromCookie;
+    }
+    return opts.defaultLocale;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-tongue",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "Compiler-first, type-safe i18n for the Next.js 16 App Router",
   "license": "MIT",
   "type": "module",