@entifix/next-i18n 0.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './with-locale.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './with-locale.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './with-locale.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB"}

package/dist/server.d.ts

@@ -0,0 +1,48 @@
+import { type Locale } from '@entifix/core';
+import type { Namespace } from 'i18next';
+/**
+ * The locale the middleware resolved for this request.
+ *
+ * Read from a header rather than a route param — that is the trade the rewrite
+ * strategy makes, and it is why the back-office route trees have no
+ * `app/[locale]` segment. Falls back to the fleet default for paths the
+ * middleware matcher skips (`/api/health`, `/api/config`), which have no
+ * user-facing copy anyway.
+ *
+ * A header is a **dynamic** request input, so a page that calls this — or
+ * {@link getServerT}, which does — can never be prerendered. That is the right
+ * trade for an auth-gated app whose every response is personal anyway, and the
+ * wrong one for a public storefront: marketplace-app therefore carries a real
+ * `[locale]` segment and reads its locale from the route param, through
+ * {@link getServerTFor}.
+ */
+export declare function getRequestLocale(): Promise<Locale>;
+/**
+ * The request-free counterpart of {@link getServerT}, for a locale the caller
+ * already holds — a route param, typically.
+ *
+ * Re-exported rather than defined here so it sits next to `getServerT` at an
+ * app's call sites while still being reachable from packages that may not
+ * depend on this one: `layer:shell` forbids same-layer edges, and the
+ * storefront shell is precisely the caller that needs it. The implementation
+ * lives in `@entifix/i18n`.
+ */
+export { getServerTFor } from '@entifix/i18n';
+/**
+ * A translate function for a server component. A fresh instance per request,
+ * because a module-level singleton would let one visitor's locale leak into
+ * another's markup under concurrent rendering.
+ */
+export declare function getServerT<N extends Namespace>(ns?: N): Promise<import("i18next").TFunction<"translation" | (N extends null ? "translation" : N), undefined>>;
+export type TranslateKey = (key: string, params?: Record<string, unknown>) => string;
+/**
+ * The server counterpart of the controls package's `useTranslateKey`: resolves
+ * keys that are only known at runtime — nav labels held in a route table, an
+ * entity's `labelKey`.
+ *
+ * Separate from {@link getServerT}, which stays strict. This is the one place
+ * the typed-key guarantee is traded away on the server, and authored copy must
+ * keep going through `getServerT` so a typo stays a compile error.
+ */
+export declare function getServerTranslateKey<N extends Namespace>(ns?: N): Promise<TranslateKey>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAGxD;AAED;;;;;;;;;GASG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,CAAC,EAAE,CAAC,yGAG3D;AAED,MAAM,MAAM,YAAY,GAAG,CACzB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,MAAM,CAAC;AAEZ;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,SAAS,SAAS,EAC7D,EAAE,CAAC,EAAE,CAAC,GACL,OAAO,CAAC,YAAY,CAAC,CAGvB"}

package/dist/server.js

@@ -0,0 +1,54 @@
+import { DEFAULT_LOCALE, isLocale, LOCALE_HEADER } from '@entifix/core';
+import { createI18n } from '@entifix/i18n';
+import { headers } from 'next/headers';
+/**
+ * The locale the middleware resolved for this request.
+ *
+ * Read from a header rather than a route param — that is the trade the rewrite
+ * strategy makes, and it is why the back-office route trees have no
+ * `app/[locale]` segment. Falls back to the fleet default for paths the
+ * middleware matcher skips (`/api/health`, `/api/config`), which have no
+ * user-facing copy anyway.
+ *
+ * A header is a **dynamic** request input, so a page that calls this — or
+ * {@link getServerT}, which does — can never be prerendered. That is the right
+ * trade for an auth-gated app whose every response is personal anyway, and the
+ * wrong one for a public storefront: marketplace-app therefore carries a real
+ * `[locale]` segment and reads its locale from the route param, through
+ * {@link getServerTFor}.
+ */ export async function getRequestLocale() {
+    const value = (await headers()).get(LOCALE_HEADER);
+    return isLocale(value) ? value : DEFAULT_LOCALE;
+}
+/**
+ * The request-free counterpart of {@link getServerT}, for a locale the caller
+ * already holds — a route param, typically.
+ *
+ * Re-exported rather than defined here so it sits next to `getServerT` at an
+ * app's call sites while still being reachable from packages that may not
+ * depend on this one: `layer:shell` forbids same-layer edges, and the
+ * storefront shell is precisely the caller that needs it. The implementation
+ * lives in `@entifix/i18n`.
+ */ export { getServerTFor } from '@entifix/i18n';
+/**
+ * A translate function for a server component. A fresh instance per request,
+ * because a module-level singleton would let one visitor's locale leak into
+ * another's markup under concurrent rendering.
+ */ export async function getServerT(ns) {
+    const locale = await getRequestLocale();
+    return createI18n(locale).getFixedT(locale, ns != null ? ns : null);
+}
+/**
+ * The server counterpart of the controls package's `useTranslateKey`: resolves
+ * keys that are only known at runtime — nav labels held in a route table, an
+ * entity's `labelKey`.
+ *
+ * Separate from {@link getServerT}, which stays strict. This is the one place
+ * the typed-key guarantee is traded away on the server, and authored copy must
+ * keep going through `getServerT` so a typo stays a compile error.
+ */ export async function getServerTranslateKey(ns) {
+    const t = await getServerT(ns);
+    return t;
+}
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server.ts"],"sourcesContent":["import {\n  DEFAULT_LOCALE,\n  isLocale,\n  type Locale,\n  LOCALE_HEADER,\n} from '@entifix/core';\nimport { createI18n } from '@entifix/i18n';\nimport type { Namespace } from 'i18next';\nimport { headers } from 'next/headers';\n\n/**\n * The locale the middleware resolved for this request.\n *\n * Read from a header rather than a route param — that is the trade the rewrite\n * strategy makes, and it is why the back-office route trees have no\n * `app/[locale]` segment. Falls back to the fleet default for paths the\n * middleware matcher skips (`/api/health`, `/api/config`), which have no\n * user-facing copy anyway.\n *\n * A header is a **dynamic** request input, so a page that calls this — or\n * {@link getServerT}, which does — can never be prerendered. That is the right\n * trade for an auth-gated app whose every response is personal anyway, and the\n * wrong one for a public storefront: marketplace-app therefore carries a real\n * `[locale]` segment and reads its locale from the route param, through\n * {@link getServerTFor}.\n */\nexport async function getRequestLocale(): Promise<Locale> {\n  const value = (await headers()).get(LOCALE_HEADER);\n  return isLocale(value) ? value : DEFAULT_LOCALE;\n}\n\n/**\n * The request-free counterpart of {@link getServerT}, for a locale the caller\n * already holds — a route param, typically.\n *\n * Re-exported rather than defined here so it sits next to `getServerT` at an\n * app's call sites while still being reachable from packages that may not\n * depend on this one: `layer:shell` forbids same-layer edges, and the\n * storefront shell is precisely the caller that needs it. The implementation\n * lives in `@entifix/i18n`.\n */\nexport { getServerTFor } from '@entifix/i18n';\n\n/**\n * A translate function for a server component. A fresh instance per request,\n * because a module-level singleton would let one visitor's locale leak into\n * another's markup under concurrent rendering.\n */\nexport async function getServerT<N extends Namespace>(ns?: N) {\n  const locale = await getRequestLocale();\n  return createI18n(locale).getFixedT(locale, ns ?? null);\n}\n\nexport type TranslateKey = (\n  key: string,\n  params?: Record<string, unknown>,\n) => string;\n\n/**\n * The server counterpart of the controls package's `useTranslateKey`: resolves\n * keys that are only known at runtime — nav labels held in a route table, an\n * entity's `labelKey`.\n *\n * Separate from {@link getServerT}, which stays strict. This is the one place\n * the typed-key guarantee is traded away on the server, and authored copy must\n * keep going through `getServerT` so a typo stays a compile error.\n */\nexport async function getServerTranslateKey<N extends Namespace>(\n  ns?: N,\n): Promise<TranslateKey> {\n  const t = await getServerT(ns);\n  return t as unknown as TranslateKey;\n}\n"],"names":["DEFAULT_LOCALE","isLocale","LOCALE_HEADER","createI18n","headers","getRequestLocale","value","get","getServerTFor","getServerT","ns","locale","getFixedT","getServerTranslateKey","t"],"mappings":"AAAA,SACEA,cAAc,EACdC,QAAQ,EAERC,aAAa,QACR,gBAAgB;AACvB,SAASC,UAAU,QAAQ,gBAAgB;AAE3C,SAASC,OAAO,QAAQ,eAAe;AAEvC;;;;;;;;;;;;;;;CAeC,GACD,OAAO,eAAeC;IACpB,MAAMC,QAAQ,AAAC,CAAA,MAAMF,SAAQ,EAAGG,GAAG,CAACL;IACpC,OAAOD,SAASK,SAASA,QAAQN;AACnC;AAEA;;;;;;;;;CASC,GACD,SAASQ,aAAa,QAAQ,gBAAgB;AAE9C;;;;CAIC,GACD,OAAO,eAAeC,WAAgCC,EAAM;IAC1D,MAAMC,SAAS,MAAMN;IACrB,OAAOF,WAAWQ,QAAQC,SAAS,CAACD,QAAQD,aAAAA,KAAM;AACpD;AAOA;;;;;;;;CAQC,GACD,OAAO,eAAeG,sBACpBH,EAAM;IAEN,MAAMI,IAAI,MAAML,WAAWC;IAC3B,OAAOI;AACT"}

package/dist/with-locale.d.ts

@@ -0,0 +1,43 @@
+import { type Locale } from '@entifix/core';
+import { type NextRequest, NextResponse } from 'next/server';
+export interface LocaleResolution {
+    readonly locale: Locale;
+    /** The path with its locale segment removed — what the route tree matches on. */
+    readonly pathname: string;
+    /**
+     * Set when the request must be bounced to a prefixed URL first. The caller
+     * returns it immediately and skips every other gate: there is nothing to
+     * authorize about a URL the visitor is not going to stay on.
+     */
+    readonly redirect?: NextResponse;
+}
+/**
+ * Resolves the locale for one request, and rewrites the path so the rest of the
+ * app never sees the prefix.
+ *
+ * Two cases:
+ *  - **unprefixed** (`/catalog`) — negotiate from cookie then `Accept-Language`,
+ *    and redirect to `/<locale>/catalog`. The locale is always visible in the
+ *    URL, so a page can be shared or bookmarked in the language it was read in.
+ *  - **prefixed** (`/es/catalog`) — take the locale from the segment and hand
+ *    back `/catalog`, which the caller rewrites to.
+ *
+ * A rewrite rather than an `app/[locale]` segment: these apps are dynamic and
+ * auth-gated, so a real route segment would buy nothing and cost a `locale`
+ * param threaded through every page in three apps.
+ */
+export declare function resolveLocale(request: NextRequest): LocaleResolution;
+/**
+ * Carries the resolved locale to the app: a request header the server
+ * components read, and a cookie so the next unprefixed visit skips negotiation.
+ * Host-scoped, matching `entifix_at`/`entifix_sid`, so the choice follows the visitor
+ * across the fleet's ports in dev.
+ */
+export declare function rememberLocale(response: NextResponse, locale: Locale): void;
+/**
+ * Rewrites a prefixed request onto the unprefixed route tree, tagging it with
+ * the locale header. Callers that need to run their own gates first can build
+ * this themselves from {@link resolveLocale}.
+ */
+export declare function rewriteToLocale(request: NextRequest, resolution: LocaleResolution): NextResponse;
+//# sourceMappingURL=with-locale.d.ts.map

package/dist/with-locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-locale.d.ts","sourceRoot":"","sources":["../src/with-locale.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;CAClC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,gBAAgB,CAmBpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,gBAAgB,GAC3B,YAAY,CAWd"}

package/dist/with-locale.js

@@ -0,0 +1,70 @@
+import { LOCALE_COOKIE, LOCALE_HEADER, localeHref, negotiateLocale, splitLocalePath } from '@entifix/core';
+import { NextResponse } from 'next/server';
+/**
+ * Resolves the locale for one request, and rewrites the path so the rest of the
+ * app never sees the prefix.
+ *
+ * Two cases:
+ *  - **unprefixed** (`/catalog`) — negotiate from cookie then `Accept-Language`,
+ *    and redirect to `/<locale>/catalog`. The locale is always visible in the
+ *    URL, so a page can be shared or bookmarked in the language it was read in.
+ *  - **prefixed** (`/es/catalog`) — take the locale from the segment and hand
+ *    back `/catalog`, which the caller rewrites to.
+ *
+ * A rewrite rather than an `app/[locale]` segment: these apps are dynamic and
+ * auth-gated, so a real route segment would buy nothing and cost a `locale`
+ * param threaded through every page in three apps.
+ */ export function resolveLocale(request) {
+    var _ref;
+    var _request_cookies_get;
+    const { locale: fromPath, rest } = splitLocalePath(request.nextUrl.pathname);
+    if (fromPath !== undefined) {
+        return {
+            locale: fromPath,
+            pathname: rest
+        };
+    }
+    const locale = negotiateLocale({
+        cookie: (_ref = (_request_cookies_get = request.cookies.get(LOCALE_COOKIE)) == null ? void 0 : _request_cookies_get.value) != null ? _ref : null,
+        acceptLanguage: request.headers.get('accept-language')
+    });
+    const target = request.nextUrl.clone();
+    target.pathname = localeHref(locale, request.nextUrl.pathname);
+    const redirect = NextResponse.redirect(target);
+    rememberLocale(redirect, locale);
+    return {
+        locale,
+        pathname: request.nextUrl.pathname,
+        redirect
+    };
+}
+/**
+ * Carries the resolved locale to the app: a request header the server
+ * components read, and a cookie so the next unprefixed visit skips negotiation.
+ * Host-scoped, matching `entifix_at`/`entifix_sid`, so the choice follows the visitor
+ * across the fleet's ports in dev.
+ */ export function rememberLocale(response, locale) {
+    response.cookies.set(LOCALE_COOKIE, locale, {
+        path: '/',
+        sameSite: 'lax'
+    });
+}
+/**
+ * Rewrites a prefixed request onto the unprefixed route tree, tagging it with
+ * the locale header. Callers that need to run their own gates first can build
+ * this themselves from {@link resolveLocale}.
+ */ export function rewriteToLocale(request, resolution) {
+    const target = request.nextUrl.clone();
+    target.pathname = resolution.pathname;
+    const headers = new Headers(request.headers);
+    headers.set(LOCALE_HEADER, resolution.locale);
+    const response = NextResponse.rewrite(target, {
+        request: {
+            headers
+        }
+    });
+    rememberLocale(response, resolution.locale);
+    return response;
+}
+
+//# sourceMappingURL=with-locale.js.map

package/dist/with-locale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-locale.ts"],"sourcesContent":["import {\n  type Locale,\n  LOCALE_COOKIE,\n  LOCALE_HEADER,\n  localeHref,\n  negotiateLocale,\n  splitLocalePath,\n} from '@entifix/core';\nimport { type NextRequest, NextResponse } from 'next/server';\n\nexport interface LocaleResolution {\n  readonly locale: Locale;\n  /** The path with its locale segment removed — what the route tree matches on. */\n  readonly pathname: string;\n  /**\n   * Set when the request must be bounced to a prefixed URL first. The caller\n   * returns it immediately and skips every other gate: there is nothing to\n   * authorize about a URL the visitor is not going to stay on.\n   */\n  readonly redirect?: NextResponse;\n}\n\n/**\n * Resolves the locale for one request, and rewrites the path so the rest of the\n * app never sees the prefix.\n *\n * Two cases:\n *  - **unprefixed** (`/catalog`) — negotiate from cookie then `Accept-Language`,\n *    and redirect to `/<locale>/catalog`. The locale is always visible in the\n *    URL, so a page can be shared or bookmarked in the language it was read in.\n *  - **prefixed** (`/es/catalog`) — take the locale from the segment and hand\n *    back `/catalog`, which the caller rewrites to.\n *\n * A rewrite rather than an `app/[locale]` segment: these apps are dynamic and\n * auth-gated, so a real route segment would buy nothing and cost a `locale`\n * param threaded through every page in three apps.\n */\nexport function resolveLocale(request: NextRequest): LocaleResolution {\n  const { locale: fromPath, rest } = splitLocalePath(request.nextUrl.pathname);\n\n  if (fromPath !== undefined) {\n    return { locale: fromPath, pathname: rest };\n  }\n\n  const locale = negotiateLocale({\n    cookie: request.cookies.get(LOCALE_COOKIE)?.value ?? null,\n    acceptLanguage: request.headers.get('accept-language'),\n  });\n\n  const target = request.nextUrl.clone();\n  target.pathname = localeHref(locale, request.nextUrl.pathname);\n\n  const redirect = NextResponse.redirect(target);\n  rememberLocale(redirect, locale);\n\n  return { locale, pathname: request.nextUrl.pathname, redirect };\n}\n\n/**\n * Carries the resolved locale to the app: a request header the server\n * components read, and a cookie so the next unprefixed visit skips negotiation.\n * Host-scoped, matching `entifix_at`/`entifix_sid`, so the choice follows the visitor\n * across the fleet's ports in dev.\n */\nexport function rememberLocale(response: NextResponse, locale: Locale): void {\n  response.cookies.set(LOCALE_COOKIE, locale, { path: '/', sameSite: 'lax' });\n}\n\n/**\n * Rewrites a prefixed request onto the unprefixed route tree, tagging it with\n * the locale header. Callers that need to run their own gates first can build\n * this themselves from {@link resolveLocale}.\n */\nexport function rewriteToLocale(\n  request: NextRequest,\n  resolution: LocaleResolution,\n): NextResponse {\n  const target = request.nextUrl.clone();\n  target.pathname = resolution.pathname;\n\n  const headers = new Headers(request.headers);\n  headers.set(LOCALE_HEADER, resolution.locale);\n\n  const response = NextResponse.rewrite(target, { request: { headers } });\n  rememberLocale(response, resolution.locale);\n\n  return response;\n}\n"],"names":["LOCALE_COOKIE","LOCALE_HEADER","localeHref","negotiateLocale","splitLocalePath","NextResponse","resolveLocale","request","locale","fromPath","rest","nextUrl","pathname","undefined","cookie","cookies","get","value","acceptLanguage","headers","target","clone","redirect","rememberLocale","response","set","path","sameSite","rewriteToLocale","resolution","Headers","rewrite"],"mappings":"AAAA,SAEEA,aAAa,EACbC,aAAa,EACbC,UAAU,EACVC,eAAe,EACfC,eAAe,QACV,gBAAgB;AACvB,SAA2BC,YAAY,QAAQ,cAAc;AAc7D;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,cAAcC,OAAoB;;QAQtCA;IAPV,MAAM,EAAEC,QAAQC,QAAQ,EAAEC,IAAI,EAAE,GAAGN,gBAAgBG,QAAQI,OAAO,CAACC,QAAQ;IAE3E,IAAIH,aAAaI,WAAW;QAC1B,OAAO;YAAEL,QAAQC;YAAUG,UAAUF;QAAK;IAC5C;IAEA,MAAMF,SAASL,gBAAgB;QAC7BW,MAAM,WAAEP,uBAAAA,QAAQQ,OAAO,CAACC,GAAG,CAAChB,mCAApBO,qBAAoCU,KAAK,mBAAI;QACrDC,gBAAgBX,QAAQY,OAAO,CAACH,GAAG,CAAC;IACtC;IAEA,MAAMI,SAASb,QAAQI,OAAO,CAACU,KAAK;IACpCD,OAAOR,QAAQ,GAAGV,WAAWM,QAAQD,QAAQI,OAAO,CAACC,QAAQ;IAE7D,MAAMU,WAAWjB,aAAaiB,QAAQ,CAACF;IACvCG,eAAeD,UAAUd;IAEzB,OAAO;QAAEA;QAAQI,UAAUL,QAAQI,OAAO,CAACC,QAAQ;QAAEU;IAAS;AAChE;AAEA;;;;;CAKC,GACD,OAAO,SAASC,eAAeC,QAAsB,EAAEhB,MAAc;IACnEgB,SAAST,OAAO,CAACU,GAAG,CAACzB,eAAeQ,QAAQ;QAAEkB,MAAM;QAAKC,UAAU;IAAM;AAC3E;AAEA;;;;CAIC,GACD,OAAO,SAASC,gBACdrB,OAAoB,EACpBsB,UAA4B;IAE5B,MAAMT,SAASb,QAAQI,OAAO,CAACU,KAAK;IACpCD,OAAOR,QAAQ,GAAGiB,WAAWjB,QAAQ;IAErC,MAAMO,UAAU,IAAIW,QAAQvB,QAAQY,OAAO;IAC3CA,QAAQM,GAAG,CAACxB,eAAe4B,WAAWrB,MAAM;IAE5C,MAAMgB,WAAWnB,aAAa0B,OAAO,CAACX,QAAQ;QAAEb,SAAS;YAAEY;QAAQ;IAAE;IACrEI,eAAeC,UAAUK,WAAWrB,MAAM;IAE1C,OAAOgB;AACT"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@entifix/next-i18n",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/next/i18n"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@entifix/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "@entifix/source": "./src/server.ts",
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "layer:shell",
+      "scope:shared",
+      "shell:base",
+      "tier:4"
+    ],
+    "sourceRoot": "packages/next/i18n/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/next/i18n/dist",
+          "main": "packages/next/i18n/src/index.ts",
+          "tsConfig": "packages/next/i18n/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23",
+    "@entifix/i18n": "0.1.0-0",
+    "@entifix/core": "0.1.0-0"
+  },
+  "peerDependencies": {
+    "next": ">=16",
+    "i18next": ">=26 <27"
+  },
+  "devDependencies": {
+    "next": "16.2.10",
+    "i18next": "26.3.6"
+  },
+  "peerDependenciesMeta": {
+    "i18next": {
+      "optional": true
+    }
+  }
+}