@entifix/react-controls 0.1.0-0

package/dist/i18n/catalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/i18n/catalog/index.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC;AAEX,qEAAqE;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,IAAI,CAAC,CAAC;AAEhE,eAAO,MAAM,mBAAmB,uBAAwB,CAAC"}

package/dist/i18n/catalog/index.js

@@ -0,0 +1,23 @@
+import { controls as enControls } from './en.js';
+import { controls as esControls } from './es.js';
+/**
+ * The one namespace `@entifix/react-controls` owns — copy for the agnostic
+ * entity UI: a table's empty state, a filter builder's operators, a form's
+ * validation messages.
+ *
+ * It ships with the components that render it, so taking the controls means
+ * taking their strings and nothing else. It used to live in the i18n package
+ * beside a back office's chrome and a marketplace's product copy.
+ */ export const controlsCatalogs = {
+    es: {
+        controls: esControls
+    },
+    en: {
+        controls: enControls
+    }
+};
+export const CONTROLS_NAMESPACES = [
+    'controls'
+];
+
+//# sourceMappingURL=index.js.map

package/dist/i18n/catalog/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/i18n/catalog/index.ts"],"sourcesContent":["import { controls as enControls } from './en.js';\nimport { controls as esControls } from './es.js';\n\n/**\n * The one namespace `@entifix/react-controls` owns — copy for the agnostic\n * entity UI: a table's empty state, a filter builder's operators, a form's\n * validation messages.\n *\n * It ships with the components that render it, so taking the controls means\n * taking their strings and nothing else. It used to live in the i18n package\n * beside a back office's chrome and a marketplace's product copy.\n */\nexport const controlsCatalogs = {\n  es: { controls: esControls },\n  en: { controls: enControls },\n} as const;\n\n/** The namespace above, for a host composing `CustomTypeOptions`. */\nexport type ControlsResources = (typeof controlsCatalogs)['es'];\n\nexport const CONTROLS_NAMESPACES = ['controls'] as const;\n"],"names":["controls","enControls","esControls","controlsCatalogs","es","en","CONTROLS_NAMESPACES"],"mappings":"AAAA,SAASA,YAAYC,UAAU,QAAQ,UAAU;AACjD,SAASD,YAAYE,UAAU,QAAQ,UAAU;AAEjD;;;;;;;;CAQC,GACD,OAAO,MAAMC,mBAAmB;IAC9BC,IAAI;QAAEJ,UAAUE;IAAW;IAC3BG,IAAI;QAAEL,UAAUC;IAAW;AAC7B,EAAW;AAKX,OAAO,MAAMK,sBAAsB;IAAC;CAAW,CAAU"}

package/dist/i18n/entity-labels.d.ts

@@ -0,0 +1,29 @@
+import type { EntityFieldDescriptor } from '@entifix/core';
+/**
+ * Resolves each descriptor's `labelKey` against the active catalog, leaving the
+ * declared `label` in place for members that have no key yet.
+ *
+ * Done here rather than in `describeEntityColumns` because the same descriptors
+ * are the server-side filter allowlist, where a translated label would be
+ * meaningless — and because `entifix:core` cannot reach the i18n layer.
+ */
+export declare function useLocalizedDescriptors<TDescriptor extends EntityFieldDescriptor>(descriptors: readonly TDescriptor[]): TDescriptor[];
+/**
+ * Reads one value of an enum member. Falls back to the raw value when the
+ * member declared no vocabulary prefix, which is what a `status` of `active`
+ * used to render as everywhere.
+ */
+export declare function useEnumLabel(): (descriptor: EntityFieldDescriptor, value: string) => string;
+/**
+ * Renders a failed request in the reader's language.
+ *
+ * Services answer with `{ error, code, detail }`, and the rest client carries
+ * the `code` onto `EntifixError.details`. Falling back to `message` keeps a
+ * failure that predates the vocabulary — or one raised client-side — readable
+ * rather than blank.
+ */
+export declare function useErrorMessage(): (error: {
+    message: string;
+    details?: Record<string, unknown>;
+}) => string;
+//# sourceMappingURL=entity-labels.d.ts.map

package/dist/i18n/entity-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-labels.d.ts","sourceRoot":"","sources":["../../src/i18n/entity-labels.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAK3D;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,SAAS,qBAAqB,EACzC,WAAW,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,EAAE,CAYpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,CAC9B,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,MAAM,KACV,MAAM,CAUV;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,CAAC,KAAK,EAAE;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,KAAK,MAAM,CAYX"}

package/dist/i18n/entity-labels.js

@@ -0,0 +1,49 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { useCallback, useMemo } from 'react';
+import { useTranslateKey } from './i18n-context.js';
+/**
+ * Resolves each descriptor's `labelKey` against the active catalog, leaving the
+ * declared `label` in place for members that have no key yet.
+ *
+ * Done here rather than in `describeEntityColumns` because the same descriptors
+ * are the server-side filter allowlist, where a translated label would be
+ * meaningless — and because `entifix:core` cannot reach the i18n layer.
+ */ export function useLocalizedDescriptors(descriptors) {
+    const translate = useTranslateKey();
+    return useMemo(()=>descriptors.map((descriptor)=>descriptor.labelKey === undefined ? descriptor : _extends({}, descriptor, {
+                label: translate(descriptor.labelKey)
+            })), [
+        descriptors,
+        translate
+    ]);
+}
+/**
+ * Reads one value of an enum member. Falls back to the raw value when the
+ * member declared no vocabulary prefix, which is what a `status` of `active`
+ * used to render as everywhere.
+ */ export function useEnumLabel() {
+    const translate = useTranslateKey();
+    return useCallback((descriptor, value)=>descriptor.enumLabelKey === undefined ? value : translate(`${descriptor.enumLabelKey}.${value}`), [
+        translate
+    ]);
+}
+/**
+ * Renders a failed request in the reader's language.
+ *
+ * Services answer with `{ error, code, detail }`, and the rest client carries
+ * the `code` onto `EntifixError.details`. Falling back to `message` keeps a
+ * failure that predates the vocabulary — or one raised client-side — readable
+ * rather than blank.
+ */ export function useErrorMessage() {
+    const translate = useTranslateKey();
+    return useCallback((error)=>{
+        var _error_details;
+        const code = (_error_details = error.details) == null ? void 0 : _error_details['code'];
+        return typeof code === 'string' ? translate(`errors:${code}`) : error.message;
+    }, [
+        translate
+    ]);
+}
+
+//# sourceMappingURL=entity-labels.js.map

package/dist/i18n/entity-labels.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/entity-labels.ts"],"sourcesContent":["'use client';\n\nimport type { EntityFieldDescriptor } from '@entifix/core';\nimport { useCallback, useMemo } from 'react';\n\nimport { useTranslateKey } from './i18n-context.js';\n\n/**\n * Resolves each descriptor's `labelKey` against the active catalog, leaving the\n * declared `label` in place for members that have no key yet.\n *\n * Done here rather than in `describeEntityColumns` because the same descriptors\n * are the server-side filter allowlist, where a translated label would be\n * meaningless — and because `entifix:core` cannot reach the i18n layer.\n */\nexport function useLocalizedDescriptors<\n  TDescriptor extends EntityFieldDescriptor,\n>(descriptors: readonly TDescriptor[]): TDescriptor[] {\n  const translate = useTranslateKey();\n\n  return useMemo(\n    () =>\n      descriptors.map(descriptor =>\n        descriptor.labelKey === undefined\n          ? descriptor\n          : { ...descriptor, label: translate(descriptor.labelKey) },\n      ),\n    [descriptors, translate],\n  );\n}\n\n/**\n * Reads one value of an enum member. Falls back to the raw value when the\n * member declared no vocabulary prefix, which is what a `status` of `active`\n * used to render as everywhere.\n */\nexport function useEnumLabel(): (\n  descriptor: EntityFieldDescriptor,\n  value: string,\n) => string {\n  const translate = useTranslateKey();\n\n  return useCallback(\n    (descriptor, value) =>\n      descriptor.enumLabelKey === undefined\n        ? value\n        : translate(`${descriptor.enumLabelKey}.${value}`),\n    [translate],\n  );\n}\n\n/**\n * Renders a failed request in the reader's language.\n *\n * Services answer with `{ error, code, detail }`, and the rest client carries\n * the `code` onto `EntifixError.details`. Falling back to `message` keeps a\n * failure that predates the vocabulary — or one raised client-side — readable\n * rather than blank.\n */\nexport function useErrorMessage(): (error: {\n  message: string;\n  details?: Record<string, unknown>;\n}) => string {\n  const translate = useTranslateKey();\n\n  return useCallback(\n    error => {\n      const code = error.details?.['code'];\n      return typeof code === 'string'\n        ? translate(`errors:${code}`)\n        : error.message;\n    },\n    [translate],\n  );\n}\n"],"names":["useCallback","useMemo","useTranslateKey","useLocalizedDescriptors","descriptors","translate","map","descriptor","labelKey","undefined","label","useEnumLabel","value","enumLabelKey","useErrorMessage","error","code","details","message"],"mappings":"AAAA;;AAGA,SAASA,WAAW,EAAEC,OAAO,QAAQ,QAAQ;AAE7C,SAASC,eAAe,QAAQ,oBAAoB;AAEpD;;;;;;;CAOC,GACD,OAAO,SAASC,wBAEdC,WAAmC;IACnC,MAAMC,YAAYH;IAElB,OAAOD,QACL,IACEG,YAAYE,GAAG,CAACC,CAAAA,aACdA,WAAWC,QAAQ,KAAKC,YACpBF,aACA,aAAKA;gBAAYG,OAAOL,UAAUE,WAAWC,QAAQ;iBAE7D;QAACJ;QAAaC;KAAU;AAE5B;AAEA;;;;CAIC,GACD,OAAO,SAASM;IAId,MAAMN,YAAYH;IAElB,OAAOF,YACL,CAACO,YAAYK,QACXL,WAAWM,YAAY,KAAKJ,YACxBG,QACAP,UAAU,GAAGE,WAAWM,YAAY,CAAC,CAAC,EAAED,OAAO,GACrD;QAACP;KAAU;AAEf;AAEA;;;;;;;CAOC,GACD,OAAO,SAASS;IAId,MAAMT,YAAYH;IAElB,OAAOF,YACLe,CAAAA;YACeA;QAAb,MAAMC,QAAOD,iBAAAA,MAAME,OAAO,qBAAbF,cAAe,CAAC,OAAO;QACpC,OAAO,OAAOC,SAAS,WACnBX,UAAU,CAAC,OAAO,EAAEW,MAAM,IAC1BD,MAAMG,OAAO;IACnB,GACA;QAACb;KAAU;AAEf"}

package/dist/i18n/fallback-catalogs.d.ts

@@ -0,0 +1,5 @@
+/** Adds a namespace to the no-provider fallback. Idempotent. */
+export declare function registerFallbackCatalog(namespace: string, byLocale: Readonly<Record<string, object>>): void;
+/** One namespace's catalog in one locale, or `undefined` if nobody registered it. */
+export declare function fallbackCatalogFor(namespace: string, locale: string): object | undefined;
+//# sourceMappingURL=fallback-catalogs.d.ts.map

package/dist/i18n/fallback-catalogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-catalogs.d.ts","sourceRoot":"","sources":["../../src/i18n/fallback-catalogs.ts"],"names":[],"mappings":"AAyBA,gEAAgE;AAChE,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACzC,IAAI,CAEN;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,SAAS,CAEpB"}

package/dist/i18n/fallback-catalogs.js

@@ -0,0 +1,34 @@
+import { controlsCatalogs } from './catalog/index.js';
+/**
+ * Catalogs the no-provider fallback can resolve against, by namespace.
+ *
+ * Seeded with this package's own `controls`, and open so a package that ships
+ * copy for its own components can add it — `@entifix/next-shell` registers
+ * `shell` when it is imported. The promise is the same either way: a component
+ * that ships its strings renders them without a provider, so an adopter who
+ * mounts nothing still gets working UI rather than raw keys.
+ *
+ * ⚠️ **A plain module, and it has to be.** It used to live in `i18n-context.tsx`,
+ * which is `'use client'` — and a package registers its catalog at module scope,
+ * in code a Next server also evaluates. Next refuses to call a client function
+ * from the server, so the back office failed its build on
+ * `Attempted to call registerFallbackCatalog() from the server`. The registry is
+ * only a `Map`; nothing about it needs the client.
+ */ const fallbackCatalogs = new Map([
+    [
+        'controls',
+        {
+            es: controlsCatalogs.es.controls,
+            en: controlsCatalogs.en.controls
+        }
+    ]
+]);
+/** Adds a namespace to the no-provider fallback. Idempotent. */ export function registerFallbackCatalog(namespace, byLocale) {
+    fallbackCatalogs.set(namespace, byLocale);
+}
+/** One namespace's catalog in one locale, or `undefined` if nobody registered it. */ export function fallbackCatalogFor(namespace, locale) {
+    var _fallbackCatalogs_get;
+    return (_fallbackCatalogs_get = fallbackCatalogs.get(namespace)) == null ? void 0 : _fallbackCatalogs_get[locale];
+}
+
+//# sourceMappingURL=fallback-catalogs.js.map

package/dist/i18n/fallback-catalogs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/fallback-catalogs.ts"],"sourcesContent":["import { controlsCatalogs } from './catalog/index.js';\n\n/**\n * Catalogs the no-provider fallback can resolve against, by namespace.\n *\n * Seeded with this package's own `controls`, and open so a package that ships\n * copy for its own components can add it — `@entifix/next-shell` registers\n * `shell` when it is imported. The promise is the same either way: a component\n * that ships its strings renders them without a provider, so an adopter who\n * mounts nothing still gets working UI rather than raw keys.\n *\n * ⚠️ **A plain module, and it has to be.** It used to live in `i18n-context.tsx`,\n * which is `'use client'` — and a package registers its catalog at module scope,\n * in code a Next server also evaluates. Next refuses to call a client function\n * from the server, so the back office failed its build on\n * `Attempted to call registerFallbackCatalog() from the server`. The registry is\n * only a `Map`; nothing about it needs the client.\n */\nconst fallbackCatalogs = new Map<string, Readonly<Record<string, object>>>([\n  [\n    'controls',\n    { es: controlsCatalogs.es.controls, en: controlsCatalogs.en.controls },\n  ],\n]);\n\n/** Adds a namespace to the no-provider fallback. Idempotent. */\nexport function registerFallbackCatalog(\n  namespace: string,\n  byLocale: Readonly<Record<string, object>>,\n): void {\n  fallbackCatalogs.set(namespace, byLocale);\n}\n\n/** One namespace's catalog in one locale, or `undefined` if nobody registered it. */\nexport function fallbackCatalogFor(\n  namespace: string,\n  locale: string,\n): object | undefined {\n  return fallbackCatalogs.get(namespace)?.[locale];\n}\n"],"names":["controlsCatalogs","fallbackCatalogs","Map","es","controls","en","registerFallbackCatalog","namespace","byLocale","set","fallbackCatalogFor","locale","get"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,qBAAqB;AAEtD;;;;;;;;;;;;;;;CAeC,GACD,MAAMC,mBAAmB,IAAIC,IAA8C;IACzE;QACE;QACA;YAAEC,IAAIH,iBAAiBG,EAAE,CAACC,QAAQ;YAAEC,IAAIL,iBAAiBK,EAAE,CAACD,QAAQ;QAAC;KACtE;CACF;AAED,8DAA8D,GAC9D,OAAO,SAASE,wBACdC,SAAiB,EACjBC,QAA0C;IAE1CP,iBAAiBQ,GAAG,CAACF,WAAWC;AAClC;AAEA,mFAAmF,GACnF,OAAO,SAASE,mBACdH,SAAiB,EACjBI,MAAc;QAEPV;IAAP,QAAOA,wBAAAA,iBAAiBW,GAAG,CAACL,+BAArBN,qBAAiC,CAACU,OAAO;AAClD"}

package/dist/i18n/i18n-context.d.ts

@@ -0,0 +1,62 @@
+import { type Formatters, type Locale } from '@entifix/core';
+import { type PropsWithChildren } from 'react';
+/**
+ * Resolving a key to a sentence. The whole of what a control needs from an i18n
+ * library, and deliberately not i18next's `TFunction`.
+ *
+ * ⚠️ **This port is what makes the controls adoptable on their own.** They used
+ * to import `createI18n` directly, so taking a table meant taking i18next,
+ * react-i18next and a Spanish catalog — the first of the three composition
+ * defects the tier register was written to catch. The i18next binding now lives
+ * behind `@entifix/react-controls/i18next`, and the peers it needs are optional.
+ */
+export type Translate = (key: string, params?: Record<string, unknown>) => string;
+export interface Translator {
+    readonly locale: Locale;
+    readonly formatters: Formatters;
+    /** `ns` is the namespace a caller asked for, or the default when omitted. */
+    t(ns: string | undefined, key: string, params?: Record<string, unknown>): string;
+}
+export interface TranslatorProviderProps extends PropsWithChildren {
+    readonly translator: Translator;
+}
+/**
+ * Binds one translator to the subtree.
+ *
+ * A host with no i18n library builds one of these by hand; a host using
+ * i18next mounts `I18nProvider` from `@entifix/react-controls/i18next`, which
+ * builds it from a per-locale instance.
+ */
+export declare function TranslatorProvider({ translator, children, }: TranslatorProviderProps): import("react").JSX.Element;
+/** The translator in scope, or the key-returning fallback. */
+export declare function useTranslator(): Translator;
+export declare function useLocale(): Locale;
+/**
+ * Locale-aware `Intl` wrappers. Every date and number a control renders goes
+ * through these so the server and the browser agree on the output.
+ */
+export declare function useFormatters(): Formatters;
+/**
+ * The translate function for one namespace.
+ *
+ * ⚠️ **Typed by the host, not by this package.** TypeScript permits exactly one
+ * `declare module 'i18next' { interface CustomTypeOptions }` per compilation, so
+ * the catalogs can be owned per package but the type gate cannot — a second
+ * declaration is `TS2717`. entifix therefore ships each namespace's `Resources`
+ * type and the host composes the single augmentation, which is what keeps every
+ * `useT('shell')` and `useT('app')` call site compiling exactly as before.
+ */
+export declare function useT(ns?: string): Translate;
+export type TranslateKey = Translate;
+/**
+ * Resolves a key that is only known at runtime — an entity's `labelKey`, one
+ * value out of an enum vocabulary.
+ *
+ * Deliberately separate from {@link useT}, which stays strict. This is the one
+ * place the typed-key guarantee is given up, and it is given up for keys that
+ * `@entifix/core` cannot type: core carries `labelKey` as an opaque string
+ * because it has no catalogs to check it against. Authored copy must go through
+ * `useT` so a typo stays a compile error.
+ */
+export declare function useTranslateKey(): TranslateKey;
+//# sourceMappingURL=i18n-context.d.ts.map

package/dist/i18n/i18n-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-context.d.ts","sourceRoot":"","sources":["../../src/i18n/i18n-context.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,KAAK,iBAAiB,EAGvB,MAAM,OAAO,CAAC;AAIf;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,MAAM,CAAC;AAEZ,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,6EAA6E;IAC7E,CAAC,CACC,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,MAAM,CAAC;CACX;AAyFD,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,UAAU,EACV,QAAQ,GACT,EAAE,uBAAuB,+BAGzB;AAED,8DAA8D;AAC9D,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAM3C;AAED,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAErC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAE9C"}

package/dist/i18n/i18n-context.js

@@ -0,0 +1,128 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_LOCALE, makeFormatters } from '@entifix/core';
+import { createContext, useContext, useMemo } from 'react';
+import { fallbackCatalogFor } from './fallback-catalogs.js';
+const I18nContext = /*#__PURE__*/ createContext(null);
+let fallback;
+/** `'table.empty'` → the string at that path, or `undefined`. */ const at = (catalog, key)=>{
+    let node = catalog;
+    for (const segment of key.split('.')){
+        if (typeof node !== 'object' || node === null) return undefined;
+        node = node[segment];
+    }
+    return typeof node === 'string' ? node : undefined;
+};
+/**
+ * Resolves a key, honouring i18next's `_one`/`_other` plural suffixes when the
+ * caller passed a `count`.
+ *
+ * ⚠️ **Two plural forms, not a CLDR rule set.** i18next asks `Intl.PluralRules`
+ * and handles languages with six categories; this covers the two that Spanish
+ * and English have, which is what this package's own catalog is written in. An
+ * adopter whose locale needs more than that wants the real thing — which is
+ * what `@entifix/react-controls/i18next` is, and why it exists.
+ */ const lookup = (catalog, key, params)=>{
+    const count = params == null ? void 0 : params['count'];
+    if (typeof count === 'number') {
+        const plural = at(catalog, `${key}_${count === 1 ? 'one' : 'other'}`);
+        if (plural !== undefined) return plural;
+    }
+    return at(catalog, key);
+};
+const interpolate = (text, params)=>params === undefined ? text : text.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (whole, name)=>name in params ? String(params[name]) : whole);
+/**
+ * What a control renders when nobody mounted a provider — Storybook, a unit
+ * spec, a page that forgot.
+ *
+ * Deliberately a working translator rather than a thrown error, unlike
+ * `useTheme`. These controls render inside server components, and a control
+ * that explodes on a missing ancestor is worse than one that renders Spanish:
+ * the failure mode becomes "this screen is Spanish for an English visitor",
+ * which the locale-switch e2e catches, not a blank page.
+ *
+ * It resolves against **this package's own catalog**, which is the point of the
+ * catalog living here: the controls arrive already able to speak, so an adopter
+ * who wants no i18n library at all still gets a working table rather than one
+ * captioned `table.empty`. A key outside `controls` — a host's namespace, an
+ * entity label — has nothing here to resolve against and comes back as itself.
+ */ function fallbackTranslator() {
+    fallback != null ? fallback : fallback = {
+        locale: DEFAULT_LOCALE,
+        formatters: makeFormatters(DEFAULT_LOCALE),
+        t: (ns, key, params)=>{
+            // `useTranslateKey` hands over a fully qualified `entity:gadget.label`,
+            // because a runtime key carries its own namespace. i18next strips the
+            // prefix and answers with the bare key when it cannot resolve one, and
+            // this matches that so swapping the binding in or out changes nothing a
+            // caller can see.
+            const [prefix, ...rest] = key.split(':');
+            const qualified = rest.length > 0;
+            const namespace = qualified ? prefix : ns;
+            const bare = qualified ? rest.join(':') : key;
+            const catalog = fallbackCatalogFor(namespace != null ? namespace : 'controls', DEFAULT_LOCALE);
+            if (catalog === undefined) return bare;
+            const text = lookup(catalog, bare, params);
+            return text === undefined ? bare : interpolate(text, params);
+        }
+    };
+    return fallback;
+}
+/**
+ * Binds one translator to the subtree.
+ *
+ * A host with no i18n library builds one of these by hand; a host using
+ * i18next mounts `I18nProvider` from `@entifix/react-controls/i18next`, which
+ * builds it from a per-locale instance.
+ */ export function TranslatorProvider({ translator, children }) {
+    const value = useMemo(()=>translator, [
+        translator
+    ]);
+    return /*#__PURE__*/ _jsx(I18nContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+/** The translator in scope, or the key-returning fallback. */ export function useTranslator() {
+    var _useContext;
+    return (_useContext = useContext(I18nContext)) != null ? _useContext : fallbackTranslator();
+}
+export function useLocale() {
+    return useTranslator().locale;
+}
+/**
+ * Locale-aware `Intl` wrappers. Every date and number a control renders goes
+ * through these so the server and the browser agree on the output.
+ */ export function useFormatters() {
+    return useTranslator().formatters;
+}
+/**
+ * The translate function for one namespace.
+ *
+ * ⚠️ **Typed by the host, not by this package.** TypeScript permits exactly one
+ * `declare module 'i18next' { interface CustomTypeOptions }` per compilation, so
+ * the catalogs can be owned per package but the type gate cannot — a second
+ * declaration is `TS2717`. entifix therefore ships each namespace's `Resources`
+ * type and the host composes the single augmentation, which is what keeps every
+ * `useT('shell')` and `useT('app')` call site compiling exactly as before.
+ */ export function useT(ns) {
+    const translator = useTranslator();
+    return useMemo(()=>(key, params)=>translator.t(ns, key, params), [
+        translator,
+        ns
+    ]);
+}
+/**
+ * Resolves a key that is only known at runtime — an entity's `labelKey`, one
+ * value out of an enum vocabulary.
+ *
+ * Deliberately separate from {@link useT}, which stays strict. This is the one
+ * place the typed-key guarantee is given up, and it is given up for keys that
+ * `@entifix/core` cannot type: core carries `labelKey` as an opaque string
+ * because it has no catalogs to check it against. Authored copy must go through
+ * `useT` so a typo stays a compile error.
+ */ export function useTranslateKey() {
+    return useT();
+}
+
+//# sourceMappingURL=i18n-context.js.map

package/dist/i18n/i18n-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/i18n-context.tsx"],"sourcesContent":["'use client';\n\nimport {\n  DEFAULT_LOCALE,\n  type Formatters,\n  type Locale,\n  makeFormatters,\n} from '@entifix/core';\nimport {\n  createContext,\n  type PropsWithChildren,\n  useContext,\n  useMemo,\n} from 'react';\n\nimport { fallbackCatalogFor } from './fallback-catalogs.js';\n\n/**\n * Resolving a key to a sentence. The whole of what a control needs from an i18n\n * library, and deliberately not i18next's `TFunction`.\n *\n * ⚠️ **This port is what makes the controls adoptable on their own.** They used\n * to import `createI18n` directly, so taking a table meant taking i18next,\n * react-i18next and a Spanish catalog — the first of the three composition\n * defects the tier register was written to catch. The i18next binding now lives\n * behind `@entifix/react-controls/i18next`, and the peers it needs are optional.\n */\nexport type Translate = (\n  key: string,\n  params?: Record<string, unknown>,\n) => string;\n\nexport interface Translator {\n  readonly locale: Locale;\n  readonly formatters: Formatters;\n  /** `ns` is the namespace a caller asked for, or the default when omitted. */\n  t(\n    ns: string | undefined,\n    key: string,\n    params?: Record<string, unknown>,\n  ): string;\n}\n\nconst I18nContext = createContext<Translator | null>(null);\n\nlet fallback: Translator | undefined;\n\n/** `'table.empty'` → the string at that path, or `undefined`. */\nconst at = (catalog: object, key: string): string | undefined => {\n  let node: unknown = catalog;\n  for (const segment of key.split('.')) {\n    if (typeof node !== 'object' || node === null) return undefined;\n    node = (node as Record<string, unknown>)[segment];\n  }\n  return typeof node === 'string' ? node : undefined;\n};\n\n/**\n * Resolves a key, honouring i18next's `_one`/`_other` plural suffixes when the\n * caller passed a `count`.\n *\n * ⚠️ **Two plural forms, not a CLDR rule set.** i18next asks `Intl.PluralRules`\n * and handles languages with six categories; this covers the two that Spanish\n * and English have, which is what this package's own catalog is written in. An\n * adopter whose locale needs more than that wants the real thing — which is\n * what `@entifix/react-controls/i18next` is, and why it exists.\n */\nconst lookup = (\n  catalog: object,\n  key: string,\n  params?: Record<string, unknown>,\n): string | undefined => {\n  const count = params?.['count'];\n  if (typeof count === 'number') {\n    const plural = at(catalog, `${key}_${count === 1 ? 'one' : 'other'}`);\n    if (plural !== undefined) return plural;\n  }\n  return at(catalog, key);\n};\n\nconst interpolate = (text: string, params?: Record<string, unknown>): string =>\n  params === undefined\n    ? text\n    : text.replace(/\\{\\{\\s*([\\w.]+)\\s*\\}\\}/g, (whole, name: string) =>\n        name in params ? String(params[name]) : whole,\n      );\n\n/**\n * What a control renders when nobody mounted a provider — Storybook, a unit\n * spec, a page that forgot.\n *\n * Deliberately a working translator rather than a thrown error, unlike\n * `useTheme`. These controls render inside server components, and a control\n * that explodes on a missing ancestor is worse than one that renders Spanish:\n * the failure mode becomes \"this screen is Spanish for an English visitor\",\n * which the locale-switch e2e catches, not a blank page.\n *\n * It resolves against **this package's own catalog**, which is the point of the\n * catalog living here: the controls arrive already able to speak, so an adopter\n * who wants no i18n library at all still gets a working table rather than one\n * captioned `table.empty`. A key outside `controls` — a host's namespace, an\n * entity label — has nothing here to resolve against and comes back as itself.\n */\nfunction fallbackTranslator(): Translator {\n  fallback ??= {\n    locale: DEFAULT_LOCALE,\n    formatters: makeFormatters(DEFAULT_LOCALE),\n    t: (ns, key, params) => {\n      // `useTranslateKey` hands over a fully qualified `entity:gadget.label`,\n      // because a runtime key carries its own namespace. i18next strips the\n      // prefix and answers with the bare key when it cannot resolve one, and\n      // this matches that so swapping the binding in or out changes nothing a\n      // caller can see.\n      const [prefix, ...rest] = key.split(':');\n      const qualified = rest.length > 0;\n      const namespace = qualified ? prefix : ns;\n      const bare = qualified ? rest.join(':') : key;\n\n      const catalog = fallbackCatalogFor(\n        namespace ?? 'controls',\n        DEFAULT_LOCALE,\n      );\n      if (catalog === undefined) return bare;\n      const text = lookup(catalog, bare, params);\n      return text === undefined ? bare : interpolate(text, params);\n    },\n  };\n  return fallback;\n}\n\nexport interface TranslatorProviderProps extends PropsWithChildren {\n  readonly translator: Translator;\n}\n\n/**\n * Binds one translator to the subtree.\n *\n * A host with no i18n library builds one of these by hand; a host using\n * i18next mounts `I18nProvider` from `@entifix/react-controls/i18next`, which\n * builds it from a per-locale instance.\n */\nexport function TranslatorProvider({\n  translator,\n  children,\n}: TranslatorProviderProps) {\n  const value = useMemo(() => translator, [translator]);\n  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;\n}\n\n/** The translator in scope, or the key-returning fallback. */\nexport function useTranslator(): Translator {\n  return useContext(I18nContext) ?? fallbackTranslator();\n}\n\nexport function useLocale(): Locale {\n  return useTranslator().locale;\n}\n\n/**\n * Locale-aware `Intl` wrappers. Every date and number a control renders goes\n * through these so the server and the browser agree on the output.\n */\nexport function useFormatters(): Formatters {\n  return useTranslator().formatters;\n}\n\n/**\n * The translate function for one namespace.\n *\n * ⚠️ **Typed by the host, not by this package.** TypeScript permits exactly one\n * `declare module 'i18next' { interface CustomTypeOptions }` per compilation, so\n * the catalogs can be owned per package but the type gate cannot — a second\n * declaration is `TS2717`. entifix therefore ships each namespace's `Resources`\n * type and the host composes the single augmentation, which is what keeps every\n * `useT('shell')` and `useT('app')` call site compiling exactly as before.\n */\nexport function useT(ns?: string): Translate {\n  const translator = useTranslator();\n  return useMemo(\n    () => (key, params) => translator.t(ns, key, params),\n    [translator, ns],\n  );\n}\n\nexport type TranslateKey = Translate;\n\n/**\n * Resolves a key that is only known at runtime — an entity's `labelKey`, one\n * value out of an enum vocabulary.\n *\n * Deliberately separate from {@link useT}, which stays strict. This is the one\n * place the typed-key guarantee is given up, and it is given up for keys that\n * `@entifix/core` cannot type: core carries `labelKey` as an opaque string\n * because it has no catalogs to check it against. Authored copy must go through\n * `useT` so a typo stays a compile error.\n */\nexport function useTranslateKey(): TranslateKey {\n  return useT();\n}\n"],"names":["DEFAULT_LOCALE","makeFormatters","createContext","useContext","useMemo","fallbackCatalogFor","I18nContext","fallback","at","catalog","key","node","segment","split","undefined","lookup","params","count","plural","interpolate","text","replace","whole","name","String","fallbackTranslator","locale","formatters","t","ns","prefix","rest","qualified","length","namespace","bare","join","TranslatorProvider","translator","children","value","Provider","useTranslator","useLocale","useFormatters","useT","useTranslateKey"],"mappings":"AAAA;;AAEA,SACEA,cAAc,EAGdC,cAAc,QACT,gBAAgB;AACvB,SACEC,aAAa,EAEbC,UAAU,EACVC,OAAO,QACF,QAAQ;AAEf,SAASC,kBAAkB,QAAQ,yBAAyB;AA4B5D,MAAMC,4BAAcJ,cAAiC;AAErD,IAAIK;AAEJ,+DAA+D,GAC/D,MAAMC,KAAK,CAACC,SAAiBC;IAC3B,IAAIC,OAAgBF;IACpB,KAAK,MAAMG,WAAWF,IAAIG,KAAK,CAAC,KAAM;QACpC,IAAI,OAAOF,SAAS,YAAYA,SAAS,MAAM,OAAOG;QACtDH,OAAO,AAACA,IAAgC,CAACC,QAAQ;IACnD;IACA,OAAO,OAAOD,SAAS,WAAWA,OAAOG;AAC3C;AAEA;;;;;;;;;CASC,GACD,MAAMC,SAAS,CACbN,SACAC,KACAM;IAEA,MAAMC,QAAQD,0BAAAA,MAAQ,CAAC,QAAQ;IAC/B,IAAI,OAAOC,UAAU,UAAU;QAC7B,MAAMC,SAASV,GAAGC,SAAS,GAAGC,IAAI,CAAC,EAAEO,UAAU,IAAI,QAAQ,SAAS;QACpE,IAAIC,WAAWJ,WAAW,OAAOI;IACnC;IACA,OAAOV,GAAGC,SAASC;AACrB;AAEA,MAAMS,cAAc,CAACC,MAAcJ,SACjCA,WAAWF,YACPM,OACAA,KAAKC,OAAO,CAAC,2BAA2B,CAACC,OAAOC,OAC9CA,QAAQP,SAASQ,OAAOR,MAAM,CAACO,KAAK,IAAID;AAGhD;;;;;;;;;;;;;;;CAeC,GACD,SAASG;IACPlB,mBAAAA,WAAAA,WAAa;QACXmB,QAAQ1B;QACR2B,YAAY1B,eAAeD;QAC3B4B,GAAG,CAACC,IAAInB,KAAKM;YACX,wEAAwE;YACxE,sEAAsE;YACtE,uEAAuE;YACvE,wEAAwE;YACxE,kBAAkB;YAClB,MAAM,CAACc,QAAQ,GAAGC,KAAK,GAAGrB,IAAIG,KAAK,CAAC;YACpC,MAAMmB,YAAYD,KAAKE,MAAM,GAAG;YAChC,MAAMC,YAAYF,YAAYF,SAASD;YACvC,MAAMM,OAAOH,YAAYD,KAAKK,IAAI,CAAC,OAAO1B;YAE1C,MAAMD,UAAUJ,mBACd6B,oBAAAA,YAAa,YACblC;YAEF,IAAIS,YAAYK,WAAW,OAAOqB;YAClC,MAAMf,OAAOL,OAAON,SAAS0B,MAAMnB;YACnC,OAAOI,SAASN,YAAYqB,OAAOhB,YAAYC,MAAMJ;QACvD;IACF;IACA,OAAOT;AACT;AAMA;;;;;;CAMC,GACD,OAAO,SAAS8B,mBAAmB,EACjCC,UAAU,EACVC,QAAQ,EACgB;IACxB,MAAMC,QAAQpC,QAAQ,IAAMkC,YAAY;QAACA;KAAW;IACpD,qBAAO,KAAChC,YAAYmC,QAAQ;QAACD,OAAOA;kBAAQD;;AAC9C;AAEA,4DAA4D,GAC5D,OAAO,SAASG;QACPvC;IAAP,QAAOA,cAAAA,WAAWG,wBAAXH,cAA2BsB;AACpC;AAEA,OAAO,SAASkB;IACd,OAAOD,gBAAgBhB,MAAM;AAC/B;AAEA;;;CAGC,GACD,OAAO,SAASkB;IACd,OAAOF,gBAAgBf,UAAU;AACnC;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASkB,KAAKhB,EAAW;IAC9B,MAAMS,aAAaI;IACnB,OAAOtC,QACL,IAAM,CAACM,KAAKM,SAAWsB,WAAWV,CAAC,CAACC,IAAInB,KAAKM,SAC7C;QAACsB;QAAYT;KAAG;AAEpB;AAIA;;;;;;;;;CASC,GACD,OAAO,SAASiB;IACd,OAAOD;AACT"}

package/dist/i18n/index.d.ts

@@ -0,0 +1,5 @@
+export * from './catalog/index.js';
+export * from './entity-labels.js';
+export * from './fallback-catalogs.js';
+export * from './i18n-context.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

package/dist/i18n/index.js

@@ -0,0 +1,6 @@
+export * from './catalog/index.js';
+export * from './entity-labels.js';
+export * from './fallback-catalogs.js';
+export * from './i18n-context.js';
+
+//# sourceMappingURL=index.js.map

package/dist/i18n/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/index.ts"],"sourcesContent":["export * from './catalog/index.js';\nexport * from './entity-labels.js';\nexport * from './fallback-catalogs.js';\nexport * from './i18n-context.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB;AACnC,cAAc,qBAAqB;AACnC,cAAc,yBAAyB;AACvC,cAAc,oBAAoB"}

package/dist/i18n/spec-support/catalogs.d.ts

@@ -0,0 +1,2 @@
+export declare function installSpecCatalogs(): void;
+//# sourceMappingURL=catalogs.d.ts.map

package/dist/i18n/spec-support/catalogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalogs.d.ts","sourceRoot":"","sources":["../../../src/i18n/spec-support/catalogs.ts"],"names":[],"mappings":"AAsGA,wBAAgB,mBAAmB,IAAI,IAAI,CAS1C"}

package/dist/i18n/spec-support/catalogs.js

@@ -0,0 +1,142 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { defineCatalogs } from '@entifix/i18n';
+import { controlsCatalogs } from '../catalog/index.js';
+/**
+ * Catalogs for this package's own specs.
+ *
+ * ⚠️ **`entity` and `errors` are fixtures here, not shipped catalogs.** Both are
+ * *host* namespaces now: `entity` names the adopter's entities and `errors` is
+ * the code vocabulary their services answer with, so a framework shipping either
+ * would be shipping product copy — which is exactly what
+ * [ADR 0059](../../../../../../docs/adr/0059-entifix-leaves-the-repo.md)
+ * removes. What these specs prove is that a `labelKey` resolves against whatever
+ * catalog is installed, and a fixture proves that as well as r10c's did.
+ *
+ * The keys below are the ones the specs actually name, kept verbatim so the
+ * assertions still read as sentences rather than as placeholders.
+ */ const entity = {
+    es: {
+        'product-specification': {
+            label: 'Producto',
+            plural: 'Productos',
+            fields: {
+                code: 'Código',
+                name: 'Nombre'
+            }
+        },
+        'user-identity': {
+            values: {
+                role: {
+                    admin: 'Administrador',
+                    user: 'Usuario'
+                }
+            },
+            useCases: {
+                revokeSessions: 'Cerrar sesiones',
+                revokeSessionsConfirm: '¿Cerrar todas las sesiones?'
+            }
+        },
+        'product-brand': {
+            useCases: {
+                retire: 'Retirar',
+                retireConfirm: '¿Retirar la marca?'
+            }
+        },
+        gadget: {
+            useCases: {
+                compare: 'Comparar',
+                import: 'Importar',
+                purge: 'Purgar',
+                purgeConfirm: '¿Purgar el registro?',
+                revokeSessions: 'Cerrar sesiones',
+                revokeSessionsConfirm: '¿Cerrar todas las sesiones?',
+                settleAll: 'Liquidar todo',
+                updateAspects: 'Actualizar aspectos'
+            }
+        },
+        'context-dependent': 'Depende del contexto',
+        'context-independent': 'Independiente del contexto',
+        determining: 'Determinante'
+    },
+    en: {
+        'product-specification': {
+            label: 'Product',
+            plural: 'Products',
+            fields: {
+                code: 'Code',
+                name: 'Name'
+            }
+        },
+        'user-identity': {
+            values: {
+                role: {
+                    admin: 'Administrator',
+                    user: 'User'
+                }
+            },
+            useCases: {
+                revokeSessions: 'Revoke sessions',
+                revokeSessionsConfirm: 'Revoke every session?'
+            }
+        },
+        'product-brand': {
+            useCases: {
+                retire: 'Retire',
+                retireConfirm: 'Retire the brand?'
+            }
+        },
+        gadget: {
+            useCases: {
+                compare: 'Compare',
+                import: 'Import',
+                purge: 'Purge',
+                purgeConfirm: 'Purge the record?',
+                revokeSessions: 'Revoke sessions',
+                revokeSessionsConfirm: 'Revoke every session?',
+                settleAll: 'Settle all',
+                updateAspects: 'Update aspects'
+            }
+        },
+        'context-dependent': 'Context dependent',
+        'context-independent': 'Context independent',
+        determining: 'Determining'
+    }
+};
+const errors = {
+    es: {
+        unauthenticated: 'No autenticado',
+        forbidden: 'Sin permiso',
+        notFound: 'No encontrado',
+        invalidQuery: 'La consulta no es válida.',
+        unexpected: 'Error inesperado'
+    },
+    en: {
+        unauthenticated: 'Not authenticated',
+        forbidden: 'Forbidden',
+        notFound: 'Not found',
+        invalidQuery: 'The query is not valid.',
+        unexpected: 'Unexpected error'
+    }
+};
+export function installSpecCatalogs() {
+    defineCatalogs({
+        resources: {
+            es: _extends({}, controlsCatalogs.es, {
+                entity: entity.es,
+                errors: errors.es
+            }),
+            en: _extends({}, controlsCatalogs.en, {
+                entity: entity.en,
+                errors: errors.en
+            })
+        },
+        namespaces: [
+            'controls',
+            'entity',
+            'errors'
+        ],
+        defaultNS: 'controls'
+    });
+}
+
+//# sourceMappingURL=catalogs.js.map

package/dist/i18n/spec-support/catalogs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/i18n/spec-support/catalogs.ts"],"sourcesContent":["import { defineCatalogs } from '@entifix/i18n';\n\nimport { controlsCatalogs } from '../catalog/index.js';\n\n/**\n * Catalogs for this package's own specs.\n *\n * ⚠️ **`entity` and `errors` are fixtures here, not shipped catalogs.** Both are\n * *host* namespaces now: `entity` names the adopter's entities and `errors` is\n * the code vocabulary their services answer with, so a framework shipping either\n * would be shipping product copy — which is exactly what\n * [ADR 0059](../../../../../../docs/adr/0059-entifix-leaves-the-repo.md)\n * removes. What these specs prove is that a `labelKey` resolves against whatever\n * catalog is installed, and a fixture proves that as well as r10c's did.\n *\n * The keys below are the ones the specs actually name, kept verbatim so the\n * assertions still read as sentences rather than as placeholders.\n */\nconst entity = {\n  es: {\n    'product-specification': {\n      label: 'Producto',\n      plural: 'Productos',\n      fields: { code: 'Código', name: 'Nombre' },\n    },\n    'user-identity': {\n      values: { role: { admin: 'Administrador', user: 'Usuario' } },\n      useCases: {\n        revokeSessions: 'Cerrar sesiones',\n        revokeSessionsConfirm: '¿Cerrar todas las sesiones?',\n      },\n    },\n    'product-brand': {\n      useCases: { retire: 'Retirar', retireConfirm: '¿Retirar la marca?' },\n    },\n    gadget: {\n      useCases: {\n        compare: 'Comparar',\n        import: 'Importar',\n        purge: 'Purgar',\n        purgeConfirm: '¿Purgar el registro?',\n        revokeSessions: 'Cerrar sesiones',\n        revokeSessionsConfirm: '¿Cerrar todas las sesiones?',\n        settleAll: 'Liquidar todo',\n        updateAspects: 'Actualizar aspectos',\n      },\n    },\n    'context-dependent': 'Depende del contexto',\n    'context-independent': 'Independiente del contexto',\n    determining: 'Determinante',\n  },\n  en: {\n    'product-specification': {\n      label: 'Product',\n      plural: 'Products',\n      fields: { code: 'Code', name: 'Name' },\n    },\n    'user-identity': {\n      values: { role: { admin: 'Administrator', user: 'User' } },\n      useCases: {\n        revokeSessions: 'Revoke sessions',\n        revokeSessionsConfirm: 'Revoke every session?',\n      },\n    },\n    'product-brand': {\n      useCases: { retire: 'Retire', retireConfirm: 'Retire the brand?' },\n    },\n    gadget: {\n      useCases: {\n        compare: 'Compare',\n        import: 'Import',\n        purge: 'Purge',\n        purgeConfirm: 'Purge the record?',\n        revokeSessions: 'Revoke sessions',\n        revokeSessionsConfirm: 'Revoke every session?',\n        settleAll: 'Settle all',\n        updateAspects: 'Update aspects',\n      },\n    },\n    'context-dependent': 'Context dependent',\n    'context-independent': 'Context independent',\n    determining: 'Determining',\n  },\n} as const;\n\nconst errors = {\n  es: {\n    unauthenticated: 'No autenticado',\n    forbidden: 'Sin permiso',\n    notFound: 'No encontrado',\n    invalidQuery: 'La consulta no es válida.',\n    unexpected: 'Error inesperado',\n  },\n  en: {\n    unauthenticated: 'Not authenticated',\n    forbidden: 'Forbidden',\n    notFound: 'Not found',\n    invalidQuery: 'The query is not valid.',\n    unexpected: 'Unexpected error',\n  },\n} as const;\n\nexport function installSpecCatalogs(): void {\n  defineCatalogs({\n    resources: {\n      es: { ...controlsCatalogs.es, entity: entity.es, errors: errors.es },\n      en: { ...controlsCatalogs.en, entity: entity.en, errors: errors.en },\n    },\n    namespaces: ['controls', 'entity', 'errors'],\n    defaultNS: 'controls',\n  });\n}\n"],"names":["defineCatalogs","controlsCatalogs","entity","es","label","plural","fields","code","name","values","role","admin","user","useCases","revokeSessions","revokeSessionsConfirm","retire","retireConfirm","gadget","compare","import","purge","purgeConfirm","settleAll","updateAspects","determining","en","errors","unauthenticated","forbidden","notFound","invalidQuery","unexpected","installSpecCatalogs","resources","namespaces","defaultNS"],"mappings":";AAAA,SAASA,cAAc,QAAQ,gBAAgB;AAE/C,SAASC,gBAAgB,QAAQ,sBAAsB;AAEvD;;;;;;;;;;;;;CAaC,GACD,MAAMC,SAAS;IACbC,IAAI;QACF,yBAAyB;YACvBC,OAAO;YACPC,QAAQ;YACRC,QAAQ;gBAAEC,MAAM;gBAAUC,MAAM;YAAS;QAC3C;QACA,iBAAiB;YACfC,QAAQ;gBAAEC,MAAM;oBAAEC,OAAO;oBAAiBC,MAAM;gBAAU;YAAE;YAC5DC,UAAU;gBACRC,gBAAgB;gBAChBC,uBAAuB;YACzB;QACF;QACA,iBAAiB;YACfF,UAAU;gBAAEG,QAAQ;gBAAWC,eAAe;YAAqB;QACrE;QACAC,QAAQ;YACNL,UAAU;gBACRM,SAAS;gBACTC,QAAQ;gBACRC,OAAO;gBACPC,cAAc;gBACdR,gBAAgB;gBAChBC,uBAAuB;gBACvBQ,WAAW;gBACXC,eAAe;YACjB;QACF;QACA,qBAAqB;QACrB,uBAAuB;QACvBC,aAAa;IACf;IACAC,IAAI;QACF,yBAAyB;YACvBtB,OAAO;YACPC,QAAQ;YACRC,QAAQ;gBAAEC,MAAM;gBAAQC,MAAM;YAAO;QACvC;QACA,iBAAiB;YACfC,QAAQ;gBAAEC,MAAM;oBAAEC,OAAO;oBAAiBC,MAAM;gBAAO;YAAE;YACzDC,UAAU;gBACRC,gBAAgB;gBAChBC,uBAAuB;YACzB;QACF;QACA,iBAAiB;YACfF,UAAU;gBAAEG,QAAQ;gBAAUC,eAAe;YAAoB;QACnE;QACAC,QAAQ;YACNL,UAAU;gBACRM,SAAS;gBACTC,QAAQ;gBACRC,OAAO;gBACPC,cAAc;gBACdR,gBAAgB;gBAChBC,uBAAuB;gBACvBQ,WAAW;gBACXC,eAAe;YACjB;QACF;QACA,qBAAqB;QACrB,uBAAuB;QACvBC,aAAa;IACf;AACF;AAEA,MAAME,SAAS;IACbxB,IAAI;QACFyB,iBAAiB;QACjBC,WAAW;QACXC,UAAU;QACVC,cAAc;QACdC,YAAY;IACd;IACAN,IAAI;QACFE,iBAAiB;QACjBC,WAAW;QACXC,UAAU;QACVC,cAAc;QACdC,YAAY;IACd;AACF;AAEA,OAAO,SAASC;IACdjC,eAAe;QACbkC,WAAW;YACT/B,IAAI,aAAKF,iBAAiBE,EAAE;gBAAED,QAAQA,OAAOC,EAAE;gBAAEwB,QAAQA,OAAOxB,EAAE;;YAClEuB,IAAI,aAAKzB,iBAAiByB,EAAE;gBAAExB,QAAQA,OAAOwB,EAAE;gBAAEC,QAAQA,OAAOD,EAAE;;QACpE;QACAS,YAAY;YAAC;YAAY;YAAU;SAAS;QAC5CC,WAAW;IACb;AACF"}

package/dist/i18next/index.d.ts

@@ -0,0 +1,20 @@
+import { type Locale } from '@entifix/core';
+import { type PropsWithChildren } from 'react';
+import { type Translator } from '../i18n/i18n-context.js';
+export interface I18nProviderProps extends PropsWithChildren {
+    /** Negotiated upstream — by the Next middleware in an app, by a decorator in Storybook. */
+    locale: Locale;
+}
+/**
+ * Binds one locale to the subtree. A fresh i18next instance per locale keeps
+ * concurrent server renders from sharing mutable `lng` state; `I18nextProvider`
+ * carries it so any nested `useTranslation` resolves against the same catalogs.
+ */
+export declare function I18nProvider({ locale, children }: I18nProviderProps): import("react").JSX.Element;
+/**
+ * A translator over the shared fallback instance, for a caller that has
+ * catalogs installed but no provider in the tree — a spec, a Storybook
+ * decorator that renders one control.
+ */
+export declare function fallbackI18nextTranslator(locale: Locale): Translator;
+//# sourceMappingURL=index.d.ts.map

package/dist/i18next/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18next/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAkB,MAAM,eAAe,CAAC;AAG5D,OAAO,EAAE,KAAK,iBAAiB,EAAW,MAAM,OAAO,CAAC;AAGxD,OAAO,EAAE,KAAK,UAAU,EAAsB,MAAM,yBAAyB,CAAC;AA2B9E,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,2FAA2F;IAC3F,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,iBAAiB,+BAenE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAEpE"}