@entifix/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 './instance.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,eAAe,CAAC"}

package/dist/index.js

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

package/dist/index.js.map

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

package/dist/instance.d.ts

@@ -0,0 +1,81 @@
+import { type Locale } from '@entifix/core';
+import { type i18n, type Namespace, type ThirdPartyModule } from 'i18next';
+/** One locale's catalogs, keyed by namespace. */
+export type LocaleCatalogs = Readonly<Record<string, object>>;
+/**
+ * Every catalog an application renders: entifix's framework namespaces plus the
+ * host's own, already merged.
+ *
+ * ⚠️ **Supplied by the host, never assembled here.** This package used to import
+ * five namespaces directly, two of which were r10c product copy — `'r10c Admin'`
+ * shipped inside the framework. Taking them as a value is what lets two
+ * applications with different copy share one i18next setup.
+ */
+export interface I18nCatalogs {
+    readonly resources: Readonly<Record<string, LocaleCatalogs>>;
+    readonly namespaces: readonly string[];
+    readonly defaultNS: string;
+}
+/**
+ * Hand this package the application's catalogs. Call it once, from a module
+ * every entry point imports.
+ *
+ * ⚠️ **A registry rather than an argument, and the reason is the call site.**
+ * Every other seam in entifix takes its value at a composition root — a `Layer`,
+ * a React provider, a hook option. `getServerT` has neither: it is called
+ * directly inside React server components scattered across an application, with
+ * nothing in between to thread a parameter through. So the seam is module
+ * initialization, and the failure mode is made loud below rather than silent.
+ *
+ * Locale *routing* needs none of this. `@entifix/core`'s locale helpers carry
+ * no catalogs, so Next middleware reads a cookie and a header without ever
+ * loading i18next or a single translation.
+ */
+export declare function defineCatalogs(catalogs: I18nCatalogs): void;
+/**
+ * Builds an isolated i18next instance for one locale.
+ *
+ * Always an *instance*, never the `i18next` singleton: a server renders several
+ * locales concurrently, and a shared singleton would let one request's `lng`
+ * leak into another's markup.
+ *
+ * Catalogs are bundled rather than fetched, so `init` completes synchronously
+ * (`initAsync: false`) and the first paint is already translated — no Suspense
+ * boundary, no flash of untranslated keys.
+ *
+ * `modules` is how the React binding passes `initReactI18next` without this
+ * package taking a dependency on React.
+ */
+export declare function createI18n(locale: Locale, modules?: readonly ThirdPartyModule[]): i18n;
+/**
+ * A translate function for a locale the caller already holds — a route param,
+ * typically — bound to one namespace.
+ *
+ * Request-free by construction, and that is the point: a component built on it
+ * touches neither `headers()` nor `cookies()`, so the page containing it stays
+ * statically renderable and can be prerendered once per locale. Its
+ * request-reading counterpart is `getServerT` in `@entifix/next-i18n`,
+ * which re-exports this one for symmetry at app call sites.
+ *
+ * It lives here rather than in the Next i18n shell because a `layer:shell`
+ * package may not depend on another `layer:shell` package — and the storefront
+ * shell, which has a real `[locale]` segment and therefore never reads a
+ * request, is exactly the caller that needs it.
+ */
+export declare function getServerTFor<N extends Namespace>(locale: Locale, ns?: N): import("i18next").TFunction<"translation" | (N extends null ? "translation" : N), undefined>;
+/**
+ * The instance used when no provider is mounted — Storybook, a unit spec, a
+ * screen that forgot.
+ *
+ * One per process, shared across packages on purpose. Each React package
+ * resolves copy through its own `useTranslation`, and react-i18next falls back
+ * to its *uninitialized* global when no provider is in the tree — which renders
+ * raw keys at the user. Handing every caller the same initialized default
+ * instance makes that failure mode "the fleet default locale" instead.
+ *
+ * Built lazily, so an app that always mounts a provider never pays for it.
+ */
+export declare function sharedFallbackI18n(modules?: readonly ThirdPartyModule[]): i18n;
+/** Drops the installed catalogs and the shared instance. For specs. */
+export declare function resetCatalogs(): void;
+//# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAgB,EACd,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,SAAS,CAAC;AAEjB,iDAAiD;AACjD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAE3D;AAaD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,SAAS,gBAAgB,EAAO,GACxC,IAAI,CAqBN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,gGAOxE;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,SAAS,gBAAgB,EAAO,GACxC,IAAI,CAGN;AAED,uEAAuE;AACvE,wBAAgB,aAAa,IAAI,IAAI,CAGpC"}

package/dist/instance.js

@@ -0,0 +1,102 @@
+import { DEFAULT_LOCALE, EntifixBuildError } from '@entifix/core';
+import i18next from 'i18next';
+let installed;
+/**
+ * Hand this package the application's catalogs. Call it once, from a module
+ * every entry point imports.
+ *
+ * ⚠️ **A registry rather than an argument, and the reason is the call site.**
+ * Every other seam in entifix takes its value at a composition root — a `Layer`,
+ * a React provider, a hook option. `getServerT` has neither: it is called
+ * directly inside React server components scattered across an application, with
+ * nothing in between to thread a parameter through. So the seam is module
+ * initialization, and the failure mode is made loud below rather than silent.
+ *
+ * Locale *routing* needs none of this. `@entifix/core`'s locale helpers carry
+ * no catalogs, so Next middleware reads a cookie and a header without ever
+ * loading i18next or a single translation.
+ */ export function defineCatalogs(catalogs) {
+    installed = catalogs;
+}
+const required = ()=>{
+    if (installed === undefined) {
+        throw new EntifixBuildError('No i18n catalogs are installed. Call `defineCatalogs({ resources, ' + 'namespaces, defaultNS })` once from a module every entry point ' + 'imports, before the first server render.');
+    }
+    return installed;
+};
+/**
+ * Builds an isolated i18next instance for one locale.
+ *
+ * Always an *instance*, never the `i18next` singleton: a server renders several
+ * locales concurrently, and a shared singleton would let one request's `lng`
+ * leak into another's markup.
+ *
+ * Catalogs are bundled rather than fetched, so `init` completes synchronously
+ * (`initAsync: false`) and the first paint is already translated — no Suspense
+ * boundary, no flash of untranslated keys.
+ *
+ * `modules` is how the React binding passes `initReactI18next` without this
+ * package taking a dependency on React.
+ */ export function createI18n(locale, modules = []) {
+    const catalogs = required();
+    const instance = modules.reduce((acc, module)=>acc.use(module), i18next.createInstance());
+    instance.init({
+        lng: locale,
+        fallbackLng: DEFAULT_LOCALE,
+        ns: [
+            ...catalogs.namespaces
+        ],
+        defaultNS: catalogs.defaultNS,
+        resources: catalogs.resources,
+        initAsync: false,
+        interpolation: {
+            // React escapes for us; double-escaping turns "Café" into "Café".
+            escapeValue: false
+        }
+    });
+    return instance;
+}
+/**
+ * A translate function for a locale the caller already holds — a route param,
+ * typically — bound to one namespace.
+ *
+ * Request-free by construction, and that is the point: a component built on it
+ * touches neither `headers()` nor `cookies()`, so the page containing it stays
+ * statically renderable and can be prerendered once per locale. Its
+ * request-reading counterpart is `getServerT` in `@entifix/next-i18n`,
+ * which re-exports this one for symmetry at app call sites.
+ *
+ * It lives here rather than in the Next i18n shell because a `layer:shell`
+ * package may not depend on another `layer:shell` package — and the storefront
+ * shell, which has a real `[locale]` segment and therefore never reads a
+ * request, is exactly the caller that needs it.
+ */ export function getServerTFor(locale, ns) {
+    // `Namespace` is i18next's own, so it resolves to whatever union the *host*
+    // declared in `CustomTypeOptions`. This package names no namespace of its own
+    // and imports no catalog — which is the whole point — while a caller still
+    // gets a `t` bound to the namespace it asked for, and an unknown key stays a
+    // compile error.
+    return createI18n(locale).getFixedT(locale, ns != null ? ns : null);
+}
+let shared;
+/**
+ * The instance used when no provider is mounted — Storybook, a unit spec, a
+ * screen that forgot.
+ *
+ * One per process, shared across packages on purpose. Each React package
+ * resolves copy through its own `useTranslation`, and react-i18next falls back
+ * to its *uninitialized* global when no provider is in the tree — which renders
+ * raw keys at the user. Handing every caller the same initialized default
+ * instance makes that failure mode "the fleet default locale" instead.
+ *
+ * Built lazily, so an app that always mounts a provider never pays for it.
+ */ export function sharedFallbackI18n(modules = []) {
+    shared != null ? shared : shared = createI18n(DEFAULT_LOCALE, modules);
+    return shared;
+}
+/** Drops the installed catalogs and the shared instance. For specs. */ export function resetCatalogs() {
+    installed = undefined;
+    shared = undefined;
+}
+
+//# sourceMappingURL=instance.js.map

package/dist/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instance.ts"],"sourcesContent":["import { DEFAULT_LOCALE, EntifixBuildError, type Locale } from '@entifix/core';\nimport i18next, {\n  type i18n,\n  type Namespace,\n  type ThirdPartyModule,\n} from 'i18next';\n\n/** One locale's catalogs, keyed by namespace. */\nexport type LocaleCatalogs = Readonly<Record<string, object>>;\n\n/**\n * Every catalog an application renders: entifix's framework namespaces plus the\n * host's own, already merged.\n *\n * ⚠️ **Supplied by the host, never assembled here.** This package used to import\n * five namespaces directly, two of which were r10c product copy — `'r10c Admin'`\n * shipped inside the framework. Taking them as a value is what lets two\n * applications with different copy share one i18next setup.\n */\nexport interface I18nCatalogs {\n  readonly resources: Readonly<Record<string, LocaleCatalogs>>;\n  readonly namespaces: readonly string[];\n  readonly defaultNS: string;\n}\n\nlet installed: I18nCatalogs | undefined;\n\n/**\n * Hand this package the application's catalogs. Call it once, from a module\n * every entry point imports.\n *\n * ⚠️ **A registry rather than an argument, and the reason is the call site.**\n * Every other seam in entifix takes its value at a composition root — a `Layer`,\n * a React provider, a hook option. `getServerT` has neither: it is called\n * directly inside React server components scattered across an application, with\n * nothing in between to thread a parameter through. So the seam is module\n * initialization, and the failure mode is made loud below rather than silent.\n *\n * Locale *routing* needs none of this. `@entifix/core`'s locale helpers carry\n * no catalogs, so Next middleware reads a cookie and a header without ever\n * loading i18next or a single translation.\n */\nexport function defineCatalogs(catalogs: I18nCatalogs): void {\n  installed = catalogs;\n}\n\nconst required = (): I18nCatalogs => {\n  if (installed === undefined) {\n    throw new EntifixBuildError(\n      'No i18n catalogs are installed. Call `defineCatalogs({ resources, ' +\n        'namespaces, defaultNS })` once from a module every entry point ' +\n        'imports, before the first server render.',\n    );\n  }\n  return installed;\n};\n\n/**\n * Builds an isolated i18next instance for one locale.\n *\n * Always an *instance*, never the `i18next` singleton: a server renders several\n * locales concurrently, and a shared singleton would let one request's `lng`\n * leak into another's markup.\n *\n * Catalogs are bundled rather than fetched, so `init` completes synchronously\n * (`initAsync: false`) and the first paint is already translated — no Suspense\n * boundary, no flash of untranslated keys.\n *\n * `modules` is how the React binding passes `initReactI18next` without this\n * package taking a dependency on React.\n */\nexport function createI18n(\n  locale: Locale,\n  modules: readonly ThirdPartyModule[] = [],\n): i18n {\n  const catalogs = required();\n  const instance = modules.reduce<i18n>(\n    (acc, module) => acc.use(module),\n    i18next.createInstance(),\n  );\n\n  instance.init({\n    lng: locale,\n    fallbackLng: DEFAULT_LOCALE,\n    ns: [...catalogs.namespaces],\n    defaultNS: catalogs.defaultNS,\n    resources: catalogs.resources,\n    initAsync: false,\n    interpolation: {\n      // React escapes for us; double-escaping turns \"Café\" into \"Caf&#233;\".\n      escapeValue: false,\n    },\n  });\n\n  return instance;\n}\n\n/**\n * A translate function for a locale the caller already holds — a route param,\n * typically — bound to one namespace.\n *\n * Request-free by construction, and that is the point: a component built on it\n * touches neither `headers()` nor `cookies()`, so the page containing it stays\n * statically renderable and can be prerendered once per locale. Its\n * request-reading counterpart is `getServerT` in `@entifix/next-i18n`,\n * which re-exports this one for symmetry at app call sites.\n *\n * It lives here rather than in the Next i18n shell because a `layer:shell`\n * package may not depend on another `layer:shell` package — and the storefront\n * shell, which has a real `[locale]` segment and therefore never reads a\n * request, is exactly the caller that needs it.\n */\nexport function getServerTFor<N extends Namespace>(locale: Locale, ns?: N) {\n  // `Namespace` is i18next's own, so it resolves to whatever union the *host*\n  // declared in `CustomTypeOptions`. This package names no namespace of its own\n  // and imports no catalog — which is the whole point — while a caller still\n  // gets a `t` bound to the namespace it asked for, and an unknown key stays a\n  // compile error.\n  return createI18n(locale).getFixedT(locale, ns ?? null);\n}\n\nlet shared: i18n | undefined;\n\n/**\n * The instance used when no provider is mounted — Storybook, a unit spec, a\n * screen that forgot.\n *\n * One per process, shared across packages on purpose. Each React package\n * resolves copy through its own `useTranslation`, and react-i18next falls back\n * to its *uninitialized* global when no provider is in the tree — which renders\n * raw keys at the user. Handing every caller the same initialized default\n * instance makes that failure mode \"the fleet default locale\" instead.\n *\n * Built lazily, so an app that always mounts a provider never pays for it.\n */\nexport function sharedFallbackI18n(\n  modules: readonly ThirdPartyModule[] = [],\n): i18n {\n  shared ??= createI18n(DEFAULT_LOCALE, modules);\n  return shared;\n}\n\n/** Drops the installed catalogs and the shared instance. For specs. */\nexport function resetCatalogs(): void {\n  installed = undefined;\n  shared = undefined;\n}\n"],"names":["DEFAULT_LOCALE","EntifixBuildError","i18next","installed","defineCatalogs","catalogs","required","undefined","createI18n","locale","modules","instance","reduce","acc","module","use","createInstance","init","lng","fallbackLng","ns","namespaces","defaultNS","resources","initAsync","interpolation","escapeValue","getServerTFor","getFixedT","shared","sharedFallbackI18n","resetCatalogs"],"mappings":"AAAA,SAASA,cAAc,EAAEC,iBAAiB,QAAqB,gBAAgB;AAC/E,OAAOC,aAIA,UAAU;AAoBjB,IAAIC;AAEJ;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,eAAeC,QAAsB;IACnDF,YAAYE;AACd;AAEA,MAAMC,WAAW;IACf,IAAIH,cAAcI,WAAW;QAC3B,MAAM,IAAIN,kBACR,uEACE,oEACA;IAEN;IACA,OAAOE;AACT;AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASK,WACdC,MAAc,EACdC,UAAuC,EAAE;IAEzC,MAAML,WAAWC;IACjB,MAAMK,WAAWD,QAAQE,MAAM,CAC7B,CAACC,KAAKC,SAAWD,IAAIE,GAAG,CAACD,SACzBZ,QAAQc,cAAc;IAGxBL,SAASM,IAAI,CAAC;QACZC,KAAKT;QACLU,aAAanB;QACboB,IAAI;eAAIf,SAASgB,UAAU;SAAC;QAC5BC,WAAWjB,SAASiB,SAAS;QAC7BC,WAAWlB,SAASkB,SAAS;QAC7BC,WAAW;QACXC,eAAe;YACb,uEAAuE;YACvEC,aAAa;QACf;IACF;IAEA,OAAOf;AACT;AAEA;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASgB,cAAmClB,MAAc,EAAEW,EAAM;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,2EAA2E;IAC3E,6EAA6E;IAC7E,iBAAiB;IACjB,OAAOZ,WAAWC,QAAQmB,SAAS,CAACnB,QAAQW,aAAAA,KAAM;AACpD;AAEA,IAAIS;AAEJ;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,mBACdpB,UAAuC,EAAE;IAEzCmB,iBAAAA,SAAAA,SAAWrB,WAAWR,gBAAgBU;IACtC,OAAOmB;AACT;AAEA,qEAAqE,GACrE,OAAO,SAASE;IACd5B,YAAYI;IACZsB,SAAStB;AACX"}

package/dist/routing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Kept as its own entry point for the reason it always was: Next middleware runs
+ * on the edge, and importing this package's barrel would pull the i18next
+ * runtime into a bundle that only reads a cookie and a header.
+ *
+ * What changed is where the implementation lives. Locale routing carries no
+ * catalogs and no i18next, so it belongs in `@entifix/core` — which is what
+ * makes a middleware bundle free of this package entirely.
+ */
+export { DEFAULT_LOCALE, isLocale, type Locale, LOCALE_COOKIE, LOCALE_HEADER, localeHref, type LocalePath, LOCALES, negotiateLocale, type NegotiateLocaleInput, parseAcceptLanguage, splitLocalePath, } from '@entifix/core';
+//# sourceMappingURL=routing.d.ts.map

package/dist/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,cAAc,EACd,QAAQ,EACR,KAAK,MAAM,EACX,aAAa,EACb,aAAa,EACb,UAAU,EACV,KAAK,UAAU,EACf,OAAO,EACP,eAAe,EACf,KAAK,oBAAoB,EACzB,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC"}

package/dist/routing.js

@@ -0,0 +1,11 @@
+/**
+ * Kept as its own entry point for the reason it always was: Next middleware runs
+ * on the edge, and importing this package's barrel would pull the i18next
+ * runtime into a bundle that only reads a cookie and a header.
+ *
+ * What changed is where the implementation lives. Locale routing carries no
+ * catalogs and no i18next, so it belongs in `@entifix/core` — which is what
+ * makes a middleware bundle free of this package entirely.
+ */ export { DEFAULT_LOCALE, isLocale, LOCALE_COOKIE, LOCALE_HEADER, localeHref, LOCALES, negotiateLocale, parseAcceptLanguage, splitLocalePath } from '@entifix/core';
+
+//# sourceMappingURL=routing.js.map

package/dist/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing.ts"],"sourcesContent":["/**\n * Kept as its own entry point for the reason it always was: Next middleware runs\n * on the edge, and importing this package's barrel would pull the i18next\n * runtime into a bundle that only reads a cookie and a header.\n *\n * What changed is where the implementation lives. Locale routing carries no\n * catalogs and no i18next, so it belongs in `@entifix/core` — which is what\n * makes a middleware bundle free of this package entirely.\n */\nexport {\n  DEFAULT_LOCALE,\n  isLocale,\n  type Locale,\n  LOCALE_COOKIE,\n  LOCALE_HEADER,\n  localeHref,\n  type LocalePath,\n  LOCALES,\n  negotiateLocale,\n  type NegotiateLocaleInput,\n  parseAcceptLanguage,\n  splitLocalePath,\n} from '@entifix/core';\n"],"names":["DEFAULT_LOCALE","isLocale","LOCALE_COOKIE","LOCALE_HEADER","localeHref","LOCALES","negotiateLocale","parseAcceptLanguage","splitLocalePath"],"mappings":"AAAA;;;;;;;;CAQC,GACD,SACEA,cAAc,EACdC,QAAQ,EAERC,aAAa,EACbC,aAAa,EACbC,UAAU,EAEVC,OAAO,EACPC,eAAe,EAEfC,mBAAmB,EACnBC,eAAe,QACV,gBAAgB"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@entifix/i18n",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/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"
+    },
+    "./routing": {
+      "@entifix/source": "./src/routing.ts",
+      "types": "./dist/routing.d.ts",
+      "import": "./dist/routing.js",
+      "default": "./dist/routing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "layer:entifix",
+      "scope:shared",
+      "entifix:client",
+      "tier:2"
+    ],
+    "sourceRoot": "packages/ts/i18n/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/i18n/dist",
+          "main": "packages/ts/i18n/src/index.ts",
+          "tsConfig": "packages/ts/i18n/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23",
+    "@entifix/core": "0.1.0-0"
+  },
+  "peerDependencies": {
+    "i18next": ">=26 <27"
+  },
+  "devDependencies": {
+    "i18next": "26.3.6"
+  }
+}