@intlayer/use-intl 9.0.0-canary.10 → 9.0.0-canary.12

package/dist/esm/client/useTranslations.mjs

@@ -1,8 +1,8 @@
 'use client';
 
 import { createNamespaceTranslator } from "../shared/namespaceTranslator.mjs";
-import { IntlayerClientContext } from "react-intlayer";
 import { useContext, useMemo } from "react";
+import { IntlayerClientContext } from "react-intlayer";
 
 //#region src/client/useTranslations.ts
 /**

package/dist/esm/client/useTranslations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useTranslations.mjs","names":[],"sources":["../../../src/client/useTranslations.ts"],"sourcesContent":["'use client';\n\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from 'react-intlayer';\nimport { createNamespaceTranslator } from '../shared/namespaceTranslator';\nimport type {\n  LooseTranslateFunction,\n  TranslateFunction,\n} from '../shared/translateFunctionTypes';\n\n/**\n * Overload set for {@link useTranslations}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    `string` paths, matching use-intl's scoped-namespace behaviour.\n * 3. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype UseTranslations = {\n  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;\n  (namespace: `${string}.${string}`): LooseTranslateFunction;\n  (): LooseTranslateFunction;\n};\n\n/**\n * Drop-in for use-intl's `useTranslations`.\n *\n * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),\n * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted\n * arguments (`{value, number}`). Rich text is available through `t.rich()`\n * and `t.markup()`.\n *\n * @example\n * ```tsx\n * const t = useTranslations('about');\n * t('counter.label'); // ✓ typed\n * t('items', { count: 3 }); // ICU plural\n *\n * // Scoped to a nested object (use-intl idiom)\n * const t = useTranslations('about.counter');\n * t('label'); // resolves about → counter.label\n *\n * // Rich text\n * t.rich('terms', { link: (chunks) => <a href=\"/terms\">{chunks}</a> });\n * ```\n */\nexport const useTranslations = ((namespace?: string) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(\n    () => createNamespaceTranslator(currentLocale as LocalesValues, namespace),\n    [currentLocale, namespace]\n  );\n}) as UseTranslations;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAa,oBAAoB,cAAuB;CACtD,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;AAEzE,QAAO,cACC,0BAA0B,eAAgC,UAAU,EAC1E,CAAC,eAAe,UAAU,CAC3B"}
+{"version":3,"file":"useTranslations.mjs","names":[],"sources":["../../../src/client/useTranslations.ts"],"sourcesContent":["'use client';\n\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from 'react-intlayer';\nimport { createNamespaceTranslator } from '../shared/namespaceTranslator';\nimport type {\n  LooseTranslateFunction,\n  TranslateFunction,\n  TranslateFunctionForNamespace,\n} from '../shared/translateFunctionTypes';\n\n/**\n * Overload set for {@link useTranslations}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    dot-paths under the scope, typed against the dictionary, matching\n *    use-intl's scoped-namespace behaviour.\n * 3. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype UseTranslations = {\n  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;\n  <N extends `${string}.${string}`>(\n    namespace: N\n  ): TranslateFunctionForNamespace<N>;\n  (): LooseTranslateFunction;\n};\n\n/**\n * Drop-in for use-intl's `useTranslations`.\n *\n * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),\n * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted\n * arguments (`{value, number}`). Rich text is available through `t.rich()`\n * and `t.markup()`.\n *\n * @example\n * ```tsx\n * const t = useTranslations('about');\n * t('counter.label'); // ✓ typed\n * t('items', { count: 3 }); // ICU plural\n *\n * // Scoped to a nested object (use-intl idiom)\n * const t = useTranslations('about.counter');\n * t('label'); // resolves about → counter.label\n *\n * // Rich text\n * t.rich('terms', { link: (chunks) => <a href=\"/terms\">{chunks}</a> });\n * ```\n */\nexport const useTranslations = ((namespace?: string) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(\n    () => createNamespaceTranslator(currentLocale as LocalesValues, namespace),\n    [currentLocale, namespace]\n  );\n}) as UseTranslations;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,MAAa,oBAAoB,cAAuB;CACtD,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB,IAAI,EAAE;AAEzE,QAAO,cACC,0BAA0B,eAAgC,UAAU,EAC1E,CAAC,eAAe,UAAU,CAC3B"}

package/dist/esm/core/createTranslator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createTranslator.mjs","names":[],"sources":["../../../src/core/createTranslator.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { createNamespaceTranslator } from '../shared/namespaceTranslator';\nimport type {\n  LooseTranslateFunction,\n  TranslateFunction,\n} from '../shared/translateFunctionTypes';\n\n/**\n * Configuration accepted by {@link createTranslator}.\n *\n * Mirrors use-intl's `IntlConfig`, but `messages`, `formats`, `now`,\n * `timeZone`, `onError`, and `getMessageFallback` have no effect — Intlayer\n * resolves content from its own compiled dictionaries.\n */\nexport type CreateTranslatorConfig<N extends DictionaryKeys> = {\n  /** The locale dictionaries are resolved for. */\n  locale: LocalesValues;\n  /** A bare dictionary key, or a nested `'dictionary.scope'` namespace. */\n  namespace?: N | (string & {});\n  /**\n   * @deprecated has no use case with intlayer. Messages are loaded\n   * automatically under the hood for bundle optimization reason.\n   */\n  messages?: never;\n} & Record<string, unknown>;\n\n/**\n * Overload set for {@link createTranslator}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    `string` paths, matching use-intl's scoped-namespace behaviour.\n * 3. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype CreateTranslator = {\n  <N extends DictionaryKeys>(\n    config: CreateTranslatorConfig<N> & { namespace: N }\n  ): TranslateFunction<N>;\n  (\n    config: CreateTranslatorConfig<DictionaryKeys> & {\n      namespace: `${string}.${string}`;\n    }\n  ): LooseTranslateFunction;\n  (config: CreateTranslatorConfig<DictionaryKeys>): LooseTranslateFunction;\n};\n\n/**\n * Drop-in for use-intl's `createTranslator`.\n *\n * Returns a translate function (with `rich`, `markup`, `raw`, `has`) that\n * resolves messages from Intlayer's compiled dictionaries for the given\n * `locale`. Messages support ICU MessageFormat syntax.\n *\n * @example\n * ```ts\n * const t = createTranslator({ locale: 'en', namespace: 'about' });\n * t('counter.label'); // ✓ typed\n * t('items', { count: 3 }); // ICU plural\n * ```\n */\nexport const createTranslator = (({\n  locale,\n  namespace,\n  messages: _messages,\n}: CreateTranslatorConfig<DictionaryKeys>) => {\n  if (process.env.NODE_ENV === 'development' && _messages !== undefined) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('createTranslator', CYAN)} do not pass the messages option with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  return createNamespaceTranslator(locale, namespace);\n}) as CreateTranslator;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmEA,MAAa,qBAAqB,EAChC,QACA,WACA,UAAU,gBACkC;AAC5C,KAA8C,cAAc,OAE1D,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,oBAAoB,KAAK,CAAC,iIACvC;AAGH,QAAO,0BAA0B,QAAQ,UAAU"}
+{"version":3,"file":"createTranslator.mjs","names":[],"sources":["../../../src/core/createTranslator.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { createNamespaceTranslator } from '../shared/namespaceTranslator';\nimport type {\n  LooseTranslateFunction,\n  TranslateFunction,\n  TranslateFunctionForNamespace,\n} from '../shared/translateFunctionTypes';\n\n/**\n * Configuration accepted by {@link createTranslator}.\n *\n * Mirrors use-intl's `IntlConfig`, but `messages`, `formats`, `now`,\n * `timeZone`, `onError`, and `getMessageFallback` have no effect — Intlayer\n * resolves content from its own compiled dictionaries.\n */\nexport type CreateTranslatorConfig<N extends DictionaryKeys> = {\n  /** The locale dictionaries are resolved for. */\n  locale: LocalesValues;\n  /** A bare dictionary key, or a nested `'dictionary.scope'` namespace. */\n  namespace?: N | (string & {});\n  /**\n   * @deprecated has no use case with intlayer. Messages are loaded\n   * automatically under the hood for bundle optimization reason.\n   */\n  messages?: never;\n} & Record<string, unknown>;\n\n/**\n * Overload set for {@link createTranslator}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    dot-paths under the scope, typed against the dictionary, matching\n *    use-intl's scoped-namespace behaviour.\n * 3. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype CreateTranslator = {\n  <N extends DictionaryKeys>(\n    config: CreateTranslatorConfig<N> & { namespace: N }\n  ): TranslateFunction<N>;\n  <N extends `${string}.${string}`>(\n    config: CreateTranslatorConfig<DictionaryKeys> & { namespace: N }\n  ): TranslateFunctionForNamespace<N>;\n  (config: CreateTranslatorConfig<DictionaryKeys>): LooseTranslateFunction;\n};\n\n/**\n * Drop-in for use-intl's `createTranslator`.\n *\n * Returns a translate function (with `rich`, `markup`, `raw`, `has`) that\n * resolves messages from Intlayer's compiled dictionaries for the given\n * `locale`. Messages support ICU MessageFormat syntax.\n *\n * @example\n * ```ts\n * const t = createTranslator({ locale: 'en', namespace: 'about' });\n * t('counter.label'); // ✓ typed\n * t('items', { count: 3 }); // ICU plural\n * ```\n */\nexport const createTranslator = (({\n  locale,\n  namespace,\n  messages: _messages,\n}: CreateTranslatorConfig<DictionaryKeys>) => {\n  if (process.env.NODE_ENV === 'development' && _messages !== undefined) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('createTranslator', CYAN)} do not pass the messages option with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  return createNamespaceTranslator(locale, namespace);\n}) as CreateTranslator;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmEA,MAAa,qBAAqB,EAChC,QACA,WACA,UAAU,gBACkC;AAC5C,KAA8C,cAAc,OAE1D,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,oBAAoB,KAAK,CAAC,iIACvC;AAGH,QAAO,0BAA0B,QAAQ,UAAU"}

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
+import { createDictionaryTranslator } from "./shared/namespaceTranslator.mjs";
 import { useDictionaryDynamic } from "./useDictionaryDynamic.mjs";
 import { useDictionary } from "./useDictionary.mjs";
 import { useFormatter, useMessages, useNow, useTimeZone } from "./client/helpers.mjs";
@@ -11,4 +12,4 @@ import { IntlError, IntlErrorCode } from "./core/errors.mjs";
 import { hasLocale } from "./core/hasLocale.mjs";
 import { initializeConfig } from "./core/initializeConfig.mjs";
 
-export { IntlError, IntlErrorCode, IntlProvider, _useExtracted, createFormatter, createTranslator, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+export { IntlError, IntlErrorCode, IntlProvider, _useExtracted, createDictionaryTranslator, createFormatter, createTranslator, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/esm/plugin/index.mjs

@@ -1,46 +1,13 @@
 import * as ANSIColors from "@intlayer/config/colors";
 import { colorize, getAppLogger } from "@intlayer/config/logger";
 import { join } from "node:path";
-import { runOnce } from "@intlayer/chokidar/utils";
+import { USE_INTL_CALLERS } from "@intlayer/config/callers";
 import { getConfiguration } from "@intlayer/config/node";
+import { runOnce } from "@intlayer/engine/utils";
 import { intlayer } from "vite-intlayer";
 
 //#region src/plugin/index.ts
 /**
-* Caller configurations for use-intl's translation entry points.
-*
-* Tells the intlayer field-usage analyser how to extract the dictionary key
-* (namespace) and consumed fields from `useTranslations` / `createTranslator`
-* call sites, enabling accurate dictionary pruning for projects using
-* `@intlayer/use-intl`.
-*/
-const USE_INTL_COMPAT_CALLERS = [{
-	callerName: "useTranslations",
-	importSources: [
-		"use-intl",
-		"use-intl/react",
-		"@intlayer/use-intl"
-	],
-	namespace: {
-		from: "argument",
-		index: 0
-	},
-	translationFunction: "return-value"
-}, {
-	callerName: "createTranslator",
-	importSources: [
-		"use-intl",
-		"use-intl/core",
-		"@intlayer/use-intl"
-	],
-	namespace: {
-		from: "option",
-		argumentIndex: 0,
-		property: "namespace"
-	},
-	translationFunction: "return-value"
-}];
-/**
 * A Vite plugin for use-intl compat that wraps vite-intlayer and configures
 * resolve aliases so `use-intl` imports are served by `@intlayer/use-intl`.
 *
@@ -62,7 +29,7 @@ const useIntlVitePlugin = (options) => {
 	}, { cacheTimeoutMs: 1e3 * 60 * 60 });
 	const basePlugins = intlayer({
 		...options,
-		compatCallers: [...options?.compatCallers ?? [], ...USE_INTL_COMPAT_CALLERS]
+		compatCallers: [...options?.compatCallers ?? [], ...USE_INTL_CALLERS]
 	});
 	const compatPlugin = {
 		name: "vite-use-intl-compat-plugin",

package/dist/esm/plugin/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/plugin/index.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { runOnce } from '@intlayer/chokidar/utils';\nimport * as ANSIColors from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport type { PluginOption } from 'vite';\nimport { type CompatCallerConfig, intlayer } from 'vite-intlayer';\n\n/**\n * Caller configurations for use-intl's translation entry points.\n *\n * Tells the intlayer field-usage analyser how to extract the dictionary key\n * (namespace) and consumed fields from `useTranslations` / `createTranslator`\n * call sites, enabling accurate dictionary pruning for projects using\n * `@intlayer/use-intl`.\n */\nconst USE_INTL_COMPAT_CALLERS: CompatCallerConfig[] = [\n  {\n    callerName: 'useTranslations',\n    importSources: ['use-intl', 'use-intl/react', '@intlayer/use-intl'],\n    namespace: { from: 'argument', index: 0 },\n    translationFunction: 'return-value',\n  },\n  {\n    callerName: 'createTranslator',\n    importSources: ['use-intl', 'use-intl/core', '@intlayer/use-intl'],\n    namespace: { from: 'option', argumentIndex: 0, property: 'namespace' },\n    translationFunction: 'return-value',\n  },\n];\n\n/**\n * A Vite plugin for use-intl compat that wraps vite-intlayer and configures\n * resolve aliases so `use-intl` imports are served by `@intlayer/use-intl`.\n *\n * @example\n * ```ts\n * // vite.config.ts\n * import useIntlVitePlugin from '@intlayer/use-intl/plugin';\n *\n * export default defineConfig({\n *   plugins: [useIntlVitePlugin()],\n * });\n * ```\n */\nexport const useIntlVitePlugin = (\n  options?: Parameters<typeof intlayer>[0]\n): PluginOption[] => {\n  const intlayerConfig = getConfiguration();\n  const appLogger = getAppLogger(intlayerConfig);\n\n  runOnce(\n    join(\n      intlayerConfig.system.baseDir,\n      '.intlayer',\n      'cache',\n      'intlayer-issues-invitation.lock'\n    ),\n    () => {\n      appLogger([\n        colorize(\n          'Please report any issues you met on GitHub:',\n          ANSIColors.GREY\n        ),\n        colorize(\n          'https://github.com/aymericzip/intlayer/issues',\n          ANSIColors.GREY_LIGHT\n        ),\n      ]);\n    },\n    {\n      cacheTimeoutMs: 1000 * 60 * 60, // 1 hour\n    }\n  );\n\n  const basePlugins = intlayer({\n    ...options,\n    compatCallers: [\n      ...(options?.compatCallers ?? []),\n      ...USE_INTL_COMPAT_CALLERS,\n    ],\n  });\n\n  const compatPlugin: PluginOption = {\n    name: 'vite-use-intl-compat-plugin',\n    config: () => ({\n      resolve: {\n        alias: {\n          'use-intl': '@intlayer/use-intl',\n        },\n      },\n    }),\n  };\n\n  return [\n    ...(Array.isArray(basePlugins) ? basePlugins : [basePlugins]),\n    compatPlugin,\n  ];\n};\n\nexport default useIntlVitePlugin;\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,0BAAgD,CACpD;CACE,YAAY;CACZ,eAAe;EAAC;EAAY;EAAkB;EAAqB;CACnE,WAAW;EAAE,MAAM;EAAY,OAAO;EAAG;CACzC,qBAAqB;CACtB,EACD;CACE,YAAY;CACZ,eAAe;EAAC;EAAY;EAAiB;EAAqB;CAClE,WAAW;EAAE,MAAM;EAAU,eAAe;EAAG,UAAU;EAAa;CACtE,qBAAqB;CACtB,CACF;;;;;;;;;;;;;;;AAgBD,MAAa,qBACX,YACmB;CACnB,MAAM,iBAAiB,kBAAkB;CACzC,MAAM,YAAY,aAAa,eAAe;AAE9C,SACE,KACE,eAAe,OAAO,SACtB,aACA,SACA,kCACD,QACK;AACJ,YAAU,CACR,SACE,+CACA,WAAW,KACZ,EACD,SACE,iDACA,WAAW,WACZ,CACF,CAAC;IAEJ,EACE,gBAAgB,MAAO,KAAK,IAC7B,CACF;CAED,MAAM,cAAc,SAAS;EAC3B,GAAG;EACH,eAAe,CACb,GAAI,SAAS,iBAAiB,EAAE,EAChC,GAAG,wBACJ;EACF,CAAC;CAEF,MAAM,eAA6B;EACjC,MAAM;EACN,eAAe,EACb,SAAS,EACP,OAAO,EACL,YAAY,sBACb,EACF,EACF;EACF;AAED,QAAO,CACL,GAAI,MAAM,QAAQ,YAAY,GAAG,cAAc,CAAC,YAAY,EAC5D,aACD"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/plugin/index.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { USE_INTL_CALLERS } from '@intlayer/config/callers';\nimport * as ANSIColors from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { runOnce } from '@intlayer/engine/utils';\nimport type { PluginOption } from 'vite';\nimport { intlayer } from 'vite-intlayer';\n\n/**\n * A Vite plugin for use-intl compat that wraps vite-intlayer and configures\n * resolve aliases so `use-intl` imports are served by `@intlayer/use-intl`.\n *\n * @example\n * ```ts\n * // vite.config.ts\n * import useIntlVitePlugin from '@intlayer/use-intl/plugin';\n *\n * export default defineConfig({\n *   plugins: [useIntlVitePlugin()],\n * });\n * ```\n */\nexport const useIntlVitePlugin = (\n  options?: Parameters<typeof intlayer>[0]\n): PluginOption[] => {\n  const intlayerConfig = getConfiguration();\n  const appLogger = getAppLogger(intlayerConfig);\n\n  runOnce(\n    join(\n      intlayerConfig.system.baseDir,\n      '.intlayer',\n      'cache',\n      'intlayer-issues-invitation.lock'\n    ),\n    () => {\n      appLogger([\n        colorize(\n          'Please report any issues you met on GitHub:',\n          ANSIColors.GREY\n        ),\n        colorize(\n          'https://github.com/aymericzip/intlayer/issues',\n          ANSIColors.GREY_LIGHT\n        ),\n      ]);\n    },\n    {\n      cacheTimeoutMs: 1000 * 60 * 60, // 1 hour\n    }\n  );\n\n  const basePlugins = intlayer({\n    ...options,\n    compatCallers: [...(options?.compatCallers ?? []), ...USE_INTL_CALLERS],\n  });\n\n  const compatPlugin: PluginOption = {\n    name: 'vite-use-intl-compat-plugin',\n    config: () => ({\n      resolve: {\n        alias: {\n          'use-intl': '@intlayer/use-intl',\n        },\n      },\n    }),\n  };\n\n  return [\n    ...(Array.isArray(basePlugins) ? basePlugins : [basePlugins]),\n    compatPlugin,\n  ];\n};\n\nexport default useIntlVitePlugin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,qBACX,YACmB;CACnB,MAAM,iBAAiB,kBAAkB;CACzC,MAAM,YAAY,aAAa,eAAe;AAE9C,SACE,KACE,eAAe,OAAO,SACtB,aACA,SACA,kCACD,QACK;AACJ,YAAU,CACR,SACE,+CACA,WAAW,KACZ,EACD,SACE,iDACA,WAAW,WACZ,CACF,CAAC;IAEJ,EACE,gBAAgB,MAAO,KAAK,IAC7B,CACF;CAED,MAAM,cAAc,SAAS;EAC3B,GAAG;EACH,eAAe,CAAC,GAAI,SAAS,iBAAiB,EAAE,EAAG,GAAG,iBAAiB;EACxE,CAAC;CAEF,MAAM,eAA6B;EACjC,MAAM;EACN,eAAe,EACb,SAAS,EACP,OAAO,EACL,YAAY,sBACb,EACF,EACF;EACF;AAED,QAAO,CACL,GAAI,MAAM,QAAQ,YAAY,GAAG,cAAc,CAAC,YAAY,EAC5D,aACD"}

package/dist/esm/shared/namespaceTranslator.mjs

@@ -1,31 +1,10 @@
+import { Fragment } from "react";
 import { getIntlayer } from "@intlayer/core/interpreter";
-import { parseTaggedMessage, resolveMessage } from "@intlayer/core/messageFormat";
+import { navigatePath, navigatePath as navigatePath$1, parseTaggedMessage, resolveMessage } from "@intlayer/core/messageFormat";
 import { getDictionaries } from "@intlayer/dictionaries-entry";
-import { Fragment } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 
 //#region src/shared/namespaceTranslator.tsx
-/**
-* Reads a dotted `path` (e.g. `counter.label`) out of a nested object value.
-*
-* @param objectValue - The object to read from.
-* @param path - Dot-separated path. An empty path returns `objectValue`.
-* @returns The value found at `path`, or `undefined` when any segment is absent.
-*/
-const navigatePath = (objectValue, path) => {
-	if (!path) return objectValue;
-	if (path.includes(".") && objectValue !== null && objectValue !== void 0 && typeof objectValue === "object") {
-		const flatValue = objectValue[path];
-		if (flatValue !== void 0) return flatValue;
-	}
-	const parts = path.split(".");
-	let current = objectValue;
-	for (const part of parts) {
-		if (current === null || current === void 0 || typeof current !== "object") return;
-		current = current[part];
-	}
-	return current;
-};
 /** Splits rich values into scalar interpolation values and tag renderers. */
 const splitRichValues = (values = {}) => {
 	const scalarValues = {};
@@ -70,31 +49,63 @@ const renderMarkupTokens = (tokens, renderers) => tokens.map((token) => {
 const createNamespaceTranslator = (locale, namespace) => {
 	const [dictionaryKey, ...prefixSegments] = (namespace ?? "").split(".");
 	const keyPrefix = prefixSegments.join(".");
-	const lookup = (key) => {
-		let targetDictionaryKey = dictionaryKey;
-		let path = keyPrefix ? `${keyPrefix}.${key}` : key;
-		const dictionaries = getDictionaries();
-		if (!targetDictionaryKey) {
-			const [firstSegment, ...restSegments] = key.split(".");
-			targetDictionaryKey = firstSegment;
-			path = restSegments.join(".");
-			if (!dictionaries[targetDictionaryKey]) for (const dictKey of Object.keys(dictionaries)) try {
-				const result = navigatePath(getIntlayer(dictKey, locale), key);
-				if (result !== void 0) return result;
-			} catch {}
-		}
-		try {
-			return navigatePath(getIntlayer(targetDictionaryKey, locale), path);
-		} catch {
-			return;
-		}
-	};
+	const lookup = (lookupKey) => lookupNamespaceKey(locale, dictionaryKey ?? "", keyPrefix, lookupKey);
+	return createLookupTranslator(locale, lookup, (key) => namespace ? `${namespace}.${key}` : key);
+};
+/**
+* Key-based lookup used by {@link createNamespaceTranslator}: resolves the
+* dictionary through the runtime registry (`getIntlayer`).
+*/
+const lookupNamespaceKey = (locale, dictionaryKey, keyPrefix, key) => {
+	let targetDictionaryKey = dictionaryKey;
+	let path = keyPrefix ? `${keyPrefix}.${key}` : key;
+	const dictionaries = getDictionaries();
+	if (!targetDictionaryKey) {
+		const [firstSegment, ...restSegments] = key.split(".");
+		targetDictionaryKey = firstSegment ?? key;
+		path = restSegments.join(".");
+		if (!dictionaries[targetDictionaryKey]) for (const dictKey of Object.keys(dictionaries)) try {
+			const result = navigatePath$1(getIntlayer(dictKey, locale), key);
+			if (result !== void 0) return result;
+		} catch {}
+	}
+	try {
+		return navigatePath$1(getIntlayer(targetDictionaryKey, locale), path);
+	} catch {
+		return;
+	}
+};
+/**
+* Dictionary-bound translator used by the build-optimized `useDictionary` /
+* `getDictionary` variants: instead of resolving the dictionary by key at
+* runtime, the pre-resolved content is supplied directly (the babel/swc
+* optimize pass imports the dictionary JSON at build time).
+*
+* @param locale - The locale messages are resolved for.
+* @param content - The dictionary content, already resolved for `locale`.
+* @param namespacePrefix - Optional key prefix for nested namespaces
+*   (`useTranslations('about.counter')` → content of `about`, prefix `counter`).
+* @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.
+*/
+const createDictionaryTranslator = (locale, content, namespacePrefix) => {
+	const resolveKey = (key) => namespacePrefix ? `${namespacePrefix}.${key}` : key;
+	return createLookupTranslator(locale, (key) => navigatePath$1(content, resolveKey(key)), resolveKey);
+};
+/**
+* The untyped runtime translator core shared by every factory above:
+* ICU message resolution plus the `has` / `raw` / `rich` / `markup` helpers.
+*
+* @param locale - The locale messages are resolved for.
+* @param lookup - Reads the raw content value for a message key.
+* @param missingKeyFallback - Builds the echoed key on lookup miss
+*   (use-intl convention: `namespace.key`).
+*/
+const createLookupTranslator = (locale, lookup, missingKeyFallback) => {
 	const resolveToString = (key, values = {}) => {
 		const rawValue = lookup(key);
 		if (rawValue === null || rawValue === void 0) return void 0;
 		return resolveMessage(rawValue, values, locale, "icu");
 	};
-	const missingKeyFallback = (key) => namespace ? `${namespace}.${key}` : key;
 	const translate = (key, values) => resolveToString(key, values) ?? missingKeyFallback(key);
 	return Object.assign(translate, {
 		/** Returns `true` if the given key exists in the namespace. */
@@ -125,5 +136,5 @@ const createNamespaceTranslator = (locale, namespace) => {
 };
 
 //#endregion
-export { createNamespaceTranslator, navigatePath };
+export { createDictionaryTranslator, createNamespaceTranslator, navigatePath };
 //# sourceMappingURL=namespaceTranslator.mjs.map

package/dist/esm/shared/namespaceTranslator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"namespaceTranslator.mjs","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"sourcesContent":["import { getIntlayer } from '@intlayer/core/interpreter';\nimport {\n  type MessageValues,\n  parseTaggedMessage,\n  resolveMessage,\n  type TaggedMessageToken,\n} from '@intlayer/core/messageFormat';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { Fragment, type ReactNode } from 'react';\n\n/** Chunk renderer used by `t.rich()` — maps tag children to a React node. */\nexport type RichChunkRenderer = (chunks: ReactNode) => ReactNode;\n\n/** Chunk renderer used by `t.markup()` — maps tag children to a string. */\nexport type MarkupChunkRenderer = (chunks: string) => string;\n\n/**\n * Reads a dotted `path` (e.g. `counter.label`) out of a nested object value.\n *\n * @param objectValue - The object to read from.\n * @param path - Dot-separated path. An empty path returns `objectValue`.\n * @returns The value found at `path`, or `undefined` when any segment is absent.\n */\nexport const navigatePath = (objectValue: unknown, path: string): unknown => {\n  if (!path) return objectValue;\n\n  // Try the full key as a flat property first (supports flat JSON files\n  // that use dotted keys like \"section.title\": \"value\").\n  if (\n    path.includes('.') &&\n    objectValue !== null &&\n    objectValue !== undefined &&\n    typeof objectValue === 'object'\n  ) {\n    const flatValue = (objectValue as Record<string, unknown>)[path];\n    if (flatValue !== undefined) {\n      return flatValue;\n    }\n  }\n\n  const parts = path.split('.');\n  let current: unknown = objectValue;\n  for (const part of parts) {\n    if (\n      current === null ||\n      current === undefined ||\n      typeof current !== 'object'\n    ) {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[part];\n  }\n  return current;\n};\n\n/** Splits rich values into scalar interpolation values and tag renderers. */\nconst splitRichValues = (\n  values: Record<string, unknown> = {}\n): { scalarValues: MessageValues; renderers: Record<string, unknown> } => {\n  const scalarValues: MessageValues = {};\n  const renderers: Record<string, unknown> = {};\n\n  for (const [valueKey, value] of Object.entries(values)) {\n    if (typeof value === 'function') renderers[valueKey] = value;\n    else scalarValues[valueKey] = value;\n  }\n\n  return { scalarValues, renderers };\n};\n\nconst renderRichTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): ReactNode[] =>\n  tokens.map((token, tokenIndex) => {\n    if (typeof token === 'string') return token;\n\n    const children = renderRichTokens(token.children, renderers);\n    const renderer = renderers[token.tag];\n\n    if (typeof renderer === 'function') {\n      return (\n        <Fragment key={tokenIndex}>\n          {(renderer as RichChunkRenderer)(children)}\n        </Fragment>\n      );\n    }\n\n    // No renderer provided for the tag — render its children unwrapped\n    return <Fragment key={tokenIndex}>{children}</Fragment>;\n  });\n\nconst renderMarkupTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): string =>\n  tokens\n    .map((token) => {\n      if (typeof token === 'string') return token;\n\n      const children = renderMarkupTokens(token.children, renderers);\n      const renderer = renderers[token.tag];\n\n      if (typeof renderer === 'function') {\n        return (renderer as MarkupChunkRenderer)(children);\n      }\n\n      return children;\n    })\n    .join('');\n\n/**\n * The untyped runtime translator shared by `useTranslations` (React hook) and\n * `createTranslator` (non-React core).\n *\n * Behaviour matches use-intl / next-intl:\n * - namespace `'about'` → keys resolved inside the `about` dictionary\n * - namespace `'about.counter'` → dictionary `about`, key prefix `counter`\n * - no namespace → the first segment of each key is the dictionary key\n * - messages support ICU syntax (plural, select, `#`, formatted arguments)\n * - `t.rich` / `t.markup` map `<tag>chunks</tag>` through the provided\n *   renderers; `t.raw` returns the raw value; `t.has` checks existence\n *\n * @param locale - The locale dictionaries are resolved for.\n * @param namespace - Optional dictionary key, optionally with a nested scope.\n * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.\n */\nexport const createNamespaceTranslator = (\n  locale: LocalesValues,\n  namespace?: string\n) => {\n  const [dictionaryKey, ...prefixSegments] = (namespace ?? '').split('.');\n  const keyPrefix = prefixSegments.join('.');\n\n  const lookup = (key: string): unknown => {\n    let targetDictionaryKey = dictionaryKey;\n    let path = keyPrefix ? `${keyPrefix}.${key}` : key;\n\n    const dictionaries = getDictionaries();\n\n    if (!targetDictionaryKey) {\n      // Root scope — the first key segment usually designates the dictionary\n      const [firstSegment, ...restSegments] = key.split('.');\n      targetDictionaryKey = firstSegment;\n      path = restSegments.join('.');\n\n      // If the assumed dictionary doesn't exist, we must fall back to searching all dictionaries.\n      // This supports apps migrating from standard next-intl where all messages were grouped together.\n      if (!dictionaries[targetDictionaryKey as DictionaryKeys]) {\n        for (const dictKey of Object.keys(dictionaries)) {\n          try {\n            const dictionary = getIntlayer(dictKey as DictionaryKeys, locale);\n            const result = navigatePath(dictionary, key);\n            if (result !== undefined) {\n              return result;\n            }\n          } catch {\n            // Ignore if getIntlayer throws\n          }\n        }\n      }\n    }\n\n    try {\n      const dictionary = getIntlayer(\n        targetDictionaryKey as DictionaryKeys,\n        locale\n      );\n      return navigatePath(dictionary, path);\n    } catch {\n      return undefined;\n    }\n  };\n\n  const resolveToString = (\n    key: string,\n    values: MessageValues = {}\n  ): string | undefined => {\n    const rawValue = lookup(key);\n    if (rawValue === null || rawValue === undefined) return undefined;\n    return resolveMessage(rawValue, values, locale, 'icu');\n  };\n\n  const missingKeyFallback = (key: string): string =>\n    namespace ? `${namespace}.${key}` : key;\n\n  const translate = (key: string, values?: MessageValues): string =>\n    resolveToString(key, values) ?? missingKeyFallback(key);\n\n  return Object.assign(translate, {\n    /** Returns `true` if the given key exists in the namespace. */\n    has: (key: string): boolean => lookup(key) !== undefined,\n\n    /** Returns the raw unprocessed content for the given key. */\n    raw: (key: string): unknown => lookup(key),\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup, mapping each\n     * tag through the matching renderer in `values`.\n     */\n    rich: (key: string, values?: Record<string, unknown>): ReactNode => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return <>{renderRichTokens(parseTaggedMessage(message), renderers)}</>;\n    },\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup into a string,\n     * mapping each tag through the matching string renderer in `values`.\n     */\n    markup: (key: string, values?: Record<string, unknown>): string => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return renderMarkupTokens(parseTaggedMessage(message), renderers);\n    },\n  });\n};\n\nexport type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;\n"],"mappings":"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"}
+{"version":3,"file":"namespaceTranslator.mjs","names":["navigatePath"],"sources":["../../../src/shared/namespaceTranslator.tsx"],"sourcesContent":["import { getIntlayer } from '@intlayer/core/interpreter';\nimport {\n  type MessageValues,\n  navigatePath,\n  parseTaggedMessage,\n  resolveMessage,\n  type TaggedMessageToken,\n} from '@intlayer/core/messageFormat';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { Fragment, type ReactNode } from 'react';\n\nexport { navigatePath } from '@intlayer/core/messageFormat';\n\n/** Chunk renderer used by `t.rich()` — maps tag children to a React node. */\nexport type RichChunkRenderer = (chunks: ReactNode) => ReactNode;\n\n/** Chunk renderer used by `t.markup()` — maps tag children to a string. */\nexport type MarkupChunkRenderer = (chunks: string) => string;\n\n/** Splits rich values into scalar interpolation values and tag renderers. */\nconst splitRichValues = (\n  values: Record<string, unknown> = {}\n): { scalarValues: MessageValues; renderers: Record<string, unknown> } => {\n  const scalarValues: MessageValues = {};\n  const renderers: Record<string, unknown> = {};\n\n  for (const [valueKey, value] of Object.entries(values)) {\n    if (typeof value === 'function') renderers[valueKey] = value;\n    else scalarValues[valueKey] = value;\n  }\n\n  return { scalarValues, renderers };\n};\n\nconst renderRichTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): ReactNode[] =>\n  tokens.map((token, tokenIndex) => {\n    if (typeof token === 'string') return token;\n\n    const children = renderRichTokens(token.children, renderers);\n    const renderer = renderers[token.tag];\n\n    if (typeof renderer === 'function') {\n      return (\n        <Fragment key={tokenIndex}>\n          {(renderer as RichChunkRenderer)(children)}\n        </Fragment>\n      );\n    }\n\n    // No renderer provided for the tag — render its children unwrapped\n    return <Fragment key={tokenIndex}>{children}</Fragment>;\n  });\n\nconst renderMarkupTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): string =>\n  tokens\n    .map((token) => {\n      if (typeof token === 'string') return token;\n\n      const children = renderMarkupTokens(token.children, renderers);\n      const renderer = renderers[token.tag];\n\n      if (typeof renderer === 'function') {\n        return (renderer as MarkupChunkRenderer)(children);\n      }\n\n      return children;\n    })\n    .join('');\n\n/**\n * The untyped runtime translator shared by `useTranslations` (React hook) and\n * `createTranslator` (non-React core).\n *\n * Behaviour matches use-intl / next-intl:\n * - namespace `'about'` → keys resolved inside the `about` dictionary\n * - namespace `'about.counter'` → dictionary `about`, key prefix `counter`\n * - no namespace → the first segment of each key is the dictionary key\n * - messages support ICU syntax (plural, select, `#`, formatted arguments)\n * - `t.rich` / `t.markup` map `<tag>chunks</tag>` through the provided\n *   renderers; `t.raw` returns the raw value; `t.has` checks existence\n *\n * @param locale - The locale dictionaries are resolved for.\n * @param namespace - Optional dictionary key, optionally with a nested scope.\n * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.\n */\nexport const createNamespaceTranslator = (\n  locale: LocalesValues,\n  namespace?: string\n) => {\n  const [dictionaryKey, ...prefixSegments] = (namespace ?? '').split('.');\n  const keyPrefix = prefixSegments.join('.');\n\n  const lookup = (lookupKey: string): unknown =>\n    lookupNamespaceKey(locale, dictionaryKey ?? '', keyPrefix, lookupKey);\n\n  return createLookupTranslator(locale, lookup, (key) =>\n    namespace ? `${namespace}.${key}` : key\n  );\n};\n\n/**\n * Key-based lookup used by {@link createNamespaceTranslator}: resolves the\n * dictionary through the runtime registry (`getIntlayer`).\n */\nconst lookupNamespaceKey = (\n  locale: LocalesValues,\n  dictionaryKey: string,\n  keyPrefix: string,\n  key: string\n): unknown => {\n  let targetDictionaryKey = dictionaryKey;\n  let path = keyPrefix ? `${keyPrefix}.${key}` : key;\n\n  const dictionaries = getDictionaries();\n\n  if (!targetDictionaryKey) {\n    // Root scope — the first key segment usually designates the dictionary\n    const [firstSegment, ...restSegments] = key.split('.');\n    targetDictionaryKey = firstSegment ?? key;\n    path = restSegments.join('.');\n\n    // If the assumed dictionary doesn't exist, we must fall back to searching all dictionaries.\n    // This supports apps migrating from standard next-intl where all messages were grouped together.\n    if (!dictionaries[targetDictionaryKey as DictionaryKeys]) {\n      for (const dictKey of Object.keys(dictionaries)) {\n        try {\n          const dictionary = getIntlayer(dictKey as DictionaryKeys, locale);\n          const result = navigatePath(dictionary, key);\n          if (result !== undefined) {\n            return result;\n          }\n        } catch {\n          // Ignore if getIntlayer throws\n        }\n      }\n    }\n  }\n\n  try {\n    const dictionary = getIntlayer(\n      targetDictionaryKey as DictionaryKeys,\n      locale\n    );\n    return navigatePath(dictionary, path);\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Dictionary-bound translator used by the build-optimized `useDictionary` /\n * `getDictionary` variants: instead of resolving the dictionary by key at\n * runtime, the pre-resolved content is supplied directly (the babel/swc\n * optimize pass imports the dictionary JSON at build time).\n *\n * @param locale - The locale messages are resolved for.\n * @param content - The dictionary content, already resolved for `locale`.\n * @param namespacePrefix - Optional key prefix for nested namespaces\n *   (`useTranslations('about.counter')` → content of `about`, prefix `counter`).\n * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.\n */\nexport const createDictionaryTranslator = (\n  locale: LocalesValues,\n  content: unknown,\n  namespacePrefix?: string\n) => {\n  const resolveKey = (key: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${key}` : key;\n\n  return createLookupTranslator(\n    locale,\n    (key) => navigatePath(content, resolveKey(key)),\n    resolveKey\n  );\n};\n\n/**\n * The untyped runtime translator core shared by every factory above:\n * ICU message resolution plus the `has` / `raw` / `rich` / `markup` helpers.\n *\n * @param locale - The locale messages are resolved for.\n * @param lookup - Reads the raw content value for a message key.\n * @param missingKeyFallback - Builds the echoed key on lookup miss\n *   (use-intl convention: `namespace.key`).\n */\nconst createLookupTranslator = (\n  locale: LocalesValues,\n  lookup: (key: string) => unknown,\n  missingKeyFallback: (key: string) => string\n) => {\n  const resolveToString = (\n    key: string,\n    values: MessageValues = {}\n  ): string | undefined => {\n    const rawValue = lookup(key);\n    if (rawValue === null || rawValue === undefined) return undefined;\n    return resolveMessage(rawValue, values, locale, 'icu');\n  };\n\n  const translate = (key: string, values?: MessageValues): string =>\n    resolveToString(key, values) ?? missingKeyFallback(key);\n\n  return Object.assign(translate, {\n    /** Returns `true` if the given key exists in the namespace. */\n    has: (key: string): boolean => lookup(key) !== undefined,\n\n    /** Returns the raw unprocessed content for the given key. */\n    raw: (key: string): unknown => lookup(key),\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup, mapping each\n     * tag through the matching renderer in `values`.\n     */\n    rich: (key: string, values?: Record<string, unknown>): ReactNode => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return <>{renderRichTokens(parseTaggedMessage(message), renderers)}</>;\n    },\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup into a string,\n     * mapping each tag through the matching string renderer in `values`.\n     */\n    markup: (key: string, values?: Record<string, unknown>): string => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return renderMarkupTokens(parseTaggedMessage(message), renderers);\n    },\n  });\n};\n\nexport type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;\n"],"mappings":"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"}

package/dist/esm/useDictionary.mjs

@@ -1,7 +1,8 @@
 'use client';
 
-import { navigatePath } from "./shared/namespaceTranslator.mjs";
-import { useDictionary as useDictionary$1 } from "react-intlayer";
+import { createDictionaryTranslator } from "./shared/namespaceTranslator.mjs";
+import { useContext } from "react";
+import { IntlayerClientContext, useDictionary as useDictionary$1 } from "react-intlayer";
 
 //#region src/useDictionary.ts
 /**
@@ -12,23 +13,17 @@ import { useDictionary as useDictionary$1 } from "react-intlayer";
 * JSON at build time and passes it directly here. This enables tree-shaking of
 * unused locale content.
 *
+* The returned translator matches `useTranslations` exactly (ICU messages,
+* `has`, `raw`, `rich`, `markup`).
+*
 * @example (generated by the plugin, not written manually)
 * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
 * const t = useDictionary(_abc);
 */
-const useDictionary = (dictionary, namespacePrefix) => {
-	const content = useDictionary$1(dictionary);
-	const resolveKey = (key) => namespacePrefix ? `${namespacePrefix}.${key}` : key;
-	return Object.assign((lookup, params) => {
-		const rawValue = navigatePath(content, resolveKey(String(lookup)));
-		const text = String(rawValue ?? resolveKey(String(lookup)));
-		if (!params) return text;
-		return text.replace(/\{(\w+)\}/g, (_match, key) => params[key] != null ? String(params[key]) : `{${key}}`);
-	}, {
-		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
-		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
-	});
-};
+const useDictionary = ((dictionary, namespacePrefix) => {
+	const { locale } = useContext(IntlayerClientContext) ?? {};
+	return createDictionaryTranslator(locale, useDictionary$1(dictionary), namespacePrefix);
+});
 
 //#endregion
 export { useDictionary };

package/dist/esm/useDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../src/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary as useDictionaryBase } from 'react-intlayer';\nimport { navigatePath } from './shared/namespaceTranslator';\n\n/**\n * Dictionary-accepting variant of `useTranslations`.\n *\n * Used internally by the build-time optimization: instead of looking up the\n * dictionary at runtime by key, the babel/swc plugin pre-imports the dictionary\n * JSON at build time and passes it directly here. This enables tree-shaking of\n * unused locale content.\n *\n * @example (generated by the plugin, not written manually)\n * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };\n * const t = useDictionary(_abc);\n */\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryBase(dictionary);\n\n  const resolveKey = (key: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${key}` : key;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<string>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const text = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return text;\n      return text.replace(/\\{(\\w+)\\}/g, (_match, key) =>\n        params[key] != null ? String(params[key]) : `{${key}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<string>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<string>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAa,iBACX,YACA,oBACG;CACH,MAAM,UAAUA,gBAAkB,WAAW;CAE7C,MAAM,cAAc,QAClB,kBAAkB,GAAG,gBAAgB,GAAG,QAAQ;AAElD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,OAAO,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC3D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,QAAQ,eAAe,QAAQ,QACzC,OAAO,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,GACrD;IAEH;EACE,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}
+{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../src/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport {\n  IntlayerClientContext,\n  useDictionary as useDictionaryBase,\n} from 'react-intlayer';\nimport { createDictionaryTranslator } from './shared/namespaceTranslator';\nimport type {\n  ScopedTranslateFunction,\n  TranslateFunction,\n} from './shared/translateFunctionTypes';\n\n/**\n * Overload set for {@link useDictionary}: without a prefix the translator is\n * typed against the dictionary's dot-paths; with a prefix the keys are\n * relative dot-paths under that scope.\n */\ntype UseDictionary = {\n  <T extends Dictionary>(\n    dictionary: T\n  ): TranslateFunction<T['key'] & DictionaryKeys>;\n  <T extends Dictionary, Prefix extends string>(\n    dictionary: T,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;\n};\n\n/**\n * Dictionary-accepting variant of `useTranslations`.\n *\n * Used internally by the build-time optimization: instead of looking up the\n * dictionary at runtime by key, the babel/swc plugin pre-imports the dictionary\n * JSON at build time and passes it directly here. This enables tree-shaking of\n * unused locale content.\n *\n * The returned translator matches `useTranslations` exactly (ICU messages,\n * `has`, `raw`, `rich`, `markup`).\n *\n * @example (generated by the plugin, not written manually)\n * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };\n * const t = useDictionary(_abc);\n */\nexport const useDictionary = (<T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n  const content = useDictionaryBase(dictionary);\n\n  return createDictionaryTranslator(\n    locale as LocalesValues,\n    content,\n    namespacePrefix\n  );\n}) as UseDictionary;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,kBACX,YACA,oBACG;CACH,MAAM,EAAE,WAAW,WAAW,sBAAsB,IAAI,EAAE;AAG1D,QAAO,2BACL,QAHcA,gBAAkB,WAIzB,EACP,gBACD"}

package/dist/esm/useDictionaryDynamic.mjs

@@ -1,7 +1,8 @@
 'use client';
 
-import { navigatePath } from "./shared/namespaceTranslator.mjs";
-import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer";
+import { createDictionaryTranslator } from "./shared/namespaceTranslator.mjs";
+import { useContext } from "react";
+import { IntlayerClientContext, useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer";
 
 //#region src/useDictionaryDynamic.ts
 /**
@@ -10,19 +11,10 @@ import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer";
 * Counterpart to {@link useDictionary} for dictionaries imported lazily per
 * locale. Used internally by the build-time optimization.
 */
-const useDictionaryDynamic = (dictionaryPromise, key, namespacePrefix) => {
-	const content = useDictionaryDynamic$1(dictionaryPromise, key);
-	const resolveKey = (lookupKey) => namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;
-	return Object.assign((lookup, params) => {
-		const rawValue = navigatePath(content, resolveKey(String(lookup)));
-		const text = String(rawValue ?? resolveKey(String(lookup)));
-		if (!params) return text;
-		return text.replace(/\{(\w+)\}/g, (_match, key) => params[key] != null ? String(params[key]) : `{${key}}`);
-	}, {
-		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
-		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
-	});
-};
+const useDictionaryDynamic = ((dictionaryPromise, key, namespacePrefix) => {
+	const { locale } = useContext(IntlayerClientContext) ?? {};
+	return createDictionaryTranslator(locale, useDictionaryDynamic$1(dictionaryPromise, key), namespacePrefix);
+});
 
 //#endregion
 export { useDictionaryDynamic };

package/dist/esm/useDictionaryDynamic.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../src/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'react-intlayer';\nimport { navigatePath } from './shared/namespaceTranslator';\n\n/**\n * Dynamic dictionary-accepting variant of `useTranslations`.\n *\n * Counterpart to {@link useDictionary} for dictionaries imported lazily per\n * locale. Used internally by the build-time optimization.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends string,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryDynamicBase<T, K>(dictionaryPromise, key);\n\n  const resolveKey = (lookupKey: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<string>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const text = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return text;\n      return text.replace(/\\{(\\w+)\\}/g, (_match, key) =>\n        params[key] != null ? String(params[key]) : `{${key}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<string>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<string>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,wBAIX,mBACA,KACA,oBACG;CACH,MAAM,UAAUA,uBAA+B,mBAAmB,IAAI;CAEtE,MAAM,cAAc,cAClB,kBAAkB,GAAG,gBAAgB,GAAG,cAAc;AAExD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,OAAO,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC3D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,QAAQ,eAAe,QAAQ,QACzC,OAAO,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,GACrD;IAEH;EACE,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../src/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport {\n  IntlayerClientContext,\n  useDictionaryDynamic as useDictionaryDynamicBase,\n} from 'react-intlayer';\nimport { createDictionaryTranslator } from './shared/namespaceTranslator';\nimport type {\n  ScopedTranslateFunction,\n  TranslateFunction,\n} from './shared/translateFunctionTypes';\n\n/**\n * Overload set for {@link useDictionaryDynamic}: without a prefix the\n * translator is typed against the dictionary's dot-paths; with a prefix the\n * keys are relative dot-paths under that scope.\n */\ntype UseDictionaryDynamic = {\n  <T extends Dictionary, K extends DictionaryKeys>(\n    dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n    key: K\n  ): TranslateFunction<K>;\n  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(\n    dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n    key: K,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<K, Prefix>;\n};\n\n/**\n * Dynamic dictionary-accepting variant of `useTranslations`.\n *\n * Counterpart to {@link useDictionary} for dictionaries imported lazily per\n * locale. Used internally by the build-time optimization.\n */\nexport const useDictionaryDynamic = (<\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  namespacePrefix?: string\n) => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n  const content = useDictionaryDynamicBase<T, K>(dictionaryPromise, key);\n\n  return createDictionaryTranslator(\n    locale as LocalesValues,\n    content,\n    namespacePrefix\n  );\n}) as UseDictionaryDynamic;\n"],"mappings":";;;;;;;;;;;;;AA0CA,MAAa,yBAIX,mBACA,KACA,oBACG;CACH,MAAM,EAAE,WAAW,WAAW,sBAAsB,IAAI,EAAE;AAG1D,QAAO,2BACL,QAHcA,uBAA+B,mBAAmB,IAIzD,EACP,gBACD"}

package/dist/types/client/useTranslations.d.ts

@@ -1,4 +1,4 @@
-import { LooseTranslateFunction, TranslateFunction } from "../shared/translateFunctionTypes.js";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "../shared/translateFunctionTypes.js";
 import { DictionaryKeys } from "@intlayer/types/module_augmentation";
 
 //#region src/client/useTranslations.d.ts
@@ -7,13 +7,14 @@ import { DictionaryKeys } from "@intlayer/types/module_augmentation";
  *
  * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
  * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
- *    `string` paths, matching use-intl's scoped-namespace behaviour.
+ *    dot-paths under the scope, typed against the dictionary, matching
+ *    use-intl's scoped-namespace behaviour.
  * 3. No namespace → root scope; the first segment of each key designates
  *    the dictionary (`t('about.title')`).
  */
 type UseTranslations = {
   <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
-  (namespace: `${string}.${string}`): LooseTranslateFunction;
+  <N extends `${string}.${string}`>(namespace: N): TranslateFunctionForNamespace<N>;
   (): LooseTranslateFunction;
 };
 /**

package/dist/types/client/useTranslations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/client/useTranslations.ts"],"mappings":";;;;;;AAY0C;;;;;;;KAWrC,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,iBAAA,CAAkB,CAAA;EAAA,CAC3D,SAAA,0BAAmC,sBAAA;EAAA,IAChC,sBAAA;AAAA;;;;;;;;;;;AAyBN;;;;;;;;;;;;cAAa,eAAA,EAOP,eAAA"}
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/client/useTranslations.ts"],"mappings":";;;;;;AAa0C;;;;;;;;KAYrC,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,iBAAA,CAAkB,CAAA;EAAA,kCAE1D,SAAA,EAAW,CAAA,GACV,6BAAA,CAA8B,CAAA;EAAA,IAC7B,sBAAA;AAAA;;;;;;;;;;;;;;;AAyBN;;;;;;;;cAAa,eAAA,EAOP,eAAA"}

package/dist/types/core/createTranslator.d.ts

@@ -1,4 +1,4 @@
-import { LooseTranslateFunction, TranslateFunction } from "../shared/translateFunctionTypes.js";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "../shared/translateFunctionTypes.js";
 import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/core/createTranslator.d.ts
@@ -23,7 +23,8 @@ type CreateTranslatorConfig<N extends DictionaryKeys> = {
  *
  * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
  * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
- *    `string` paths, matching use-intl's scoped-namespace behaviour.
+ *    dot-paths under the scope, typed against the dictionary, matching
+ *    use-intl's scoped-namespace behaviour.
  * 3. No namespace → root scope; the first segment of each key designates
  *    the dictionary (`t('about.title')`).
  */
@@ -31,9 +32,9 @@ type CreateTranslator = {
   <N extends DictionaryKeys>(config: CreateTranslatorConfig<N> & {
     namespace: N;
   }): TranslateFunction<N>;
-  (config: CreateTranslatorConfig<DictionaryKeys> & {
-    namespace: `${string}.${string}`;
-  }): LooseTranslateFunction;
+  <N extends `${string}.${string}`>(config: CreateTranslatorConfig<DictionaryKeys> & {
+    namespace: N;
+  }): TranslateFunctionForNamespace<N>;
   (config: CreateTranslatorConfig<DictionaryKeys>): LooseTranslateFunction;
 };
 /**

package/dist/types/core/createTranslator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../../src/core/createTranslator.ts"],"mappings":";;;;;;AAoBA;;;;;KAAY,sBAAA,WAAiC,cAAA;EAUzC,gDARF,MAAA,EAAQ,aAAA,EAQA;EANR,SAAA,GAAY,CAAA;EAJ+B;;;;EAS3C,QAAA;AAAA,IACE,MAAA;;;;AAAwB;;;;;;KAWvB,gBAAA;EAAA,WACQ,cAAA,EACT,MAAA,EAAQ,sBAAA,CAAuB,CAAA;IAAO,SAAA,EAAW,CAAA;EAAA,IAChD,iBAAA,CAAkB,CAAA;EAAA,CAEnB,MAAA,EAAQ,sBAAA,CAAuB,cAAA;IAC7B,SAAA;EAAA,IAED,sBAAA;EAAA,CACF,MAAA,EAAQ,sBAAA,CAAuB,cAAA,IAAkB,sBAAA;AAAA;;;;;;;;;;;;;;;cAiBvC,gBAAA,EAaP,gBAAA"}
+{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../../src/core/createTranslator.ts"],"mappings":";;;;;;AAqBA;;;;;KAAY,sBAAA,WAAiC,cAAA;EAUzC,gDARF,MAAA,EAAQ,aAAA,EAQA;EANR,SAAA,GAAY,CAAA;EAJ+B;;;;EAS3C,QAAA;AAAA,IACE,MAAA;;;;AAAwB;;;;;;;KAYvB,gBAAA;EAAA,WACQ,cAAA,EACT,MAAA,EAAQ,sBAAA,CAAuB,CAAA;IAAO,SAAA,EAAW,CAAA;EAAA,IAChD,iBAAA,CAAkB,CAAA;EAAA,kCAEnB,MAAA,EAAQ,sBAAA,CAAuB,cAAA;IAAoB,SAAA,EAAW,CAAA;EAAA,IAC7D,6BAAA,CAA8B,CAAA;EAAA,CAChC,MAAA,EAAQ,sBAAA,CAAuB,cAAA,IAAkB,sBAAA;AAAA;;;;;;;;;;;;;;;cAiBvC,gBAAA,EAaP,gBAAA"}

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
 import { IntlProvider, IntlProviderProps } from "./client/IntlProvider.js";
 import { useFormatter, useMessages, useNow, useTimeZone } from "./client/helpers.js";
+import { MarkupChunkRenderer, RichChunkRenderer, createDictionaryTranslator } from "./shared/namespaceTranslator.js";
+import { ContentAtPath, LooseTranslateFunction, ScopedDotPaths, ScopedTranslateFunction, TranslateFunction, TranslateFunctionForNamespace, TranslatedValue } from "./shared/translateFunctionTypes.js";
 import { useDictionary } from "./useDictionary.js";
 import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
 import { useLocale } from "./client/useLocale.js";
-import { MarkupChunkRenderer, RichChunkRenderer } from "./shared/namespaceTranslator.js";
-import { LooseTranslateFunction, TranslateFunction } from "./shared/translateFunctionTypes.js";
 import { useTranslations } from "./client/useTranslations.js";
 import { _useExtracted } from "./client/index.js";
 import { createFormatter } from "./core/createFormatter.js";
@@ -13,4 +13,4 @@ import { IntlError, IntlErrorCode } from "./core/errors.js";
 import { hasLocale } from "./core/hasLocale.js";
 import { initializeConfig } from "./core/initializeConfig.js";
 import { AbstractIntlMessages, AppConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues } from "./core/types.js";
-export { AbstractIntlMessages, AppConfig, CreateTranslatorConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, IntlError, IntlErrorCode, IntlProvider, IntlProviderProps, Locale, type LooseTranslateFunction, type MarkupChunkRenderer, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, type RichChunkRenderer, RichTagsFunction, RichTranslationValues, Timezone, type TranslateFunction, TranslationValues, _useExtracted, createFormatter, createTranslator, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+export { AbstractIntlMessages, AppConfig, type ContentAtPath, CreateTranslatorConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, IntlError, IntlErrorCode, IntlProvider, IntlProviderProps, Locale, type LooseTranslateFunction, type MarkupChunkRenderer, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, type RichChunkRenderer, RichTagsFunction, RichTranslationValues, type ScopedDotPaths, type ScopedTranslateFunction, Timezone, type TranslateFunction, type TranslateFunctionForNamespace, type TranslatedValue, TranslationValues, _useExtracted, createDictionaryTranslator, createFormatter, createTranslator, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;AA6CA;;;;;;;;;;;;cAAa,iBAAA,GACX,OAAA,GAAU,UAAA,QAAkB,QAAA,SAC3B,YAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;AAuBA;;;;;;;;;;;;cAAa,iBAAA,GACX,OAAA,GAAU,UAAA,QAAkB,QAAA,SAC3B,YAAA"}

package/dist/types/shared/namespaceTranslator.d.ts

@@ -1,20 +1,12 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { ReactNode } from "react";
-import { MessageValues } from "@intlayer/core/messageFormat";
+import { MessageValues, navigatePath } from "@intlayer/core/messageFormat";
 
 //#region src/shared/namespaceTranslator.d.ts
 /** Chunk renderer used by `t.rich()` — maps tag children to a React node. */
 type RichChunkRenderer = (chunks: ReactNode) => ReactNode;
 /** Chunk renderer used by `t.markup()` — maps tag children to a string. */
 type MarkupChunkRenderer = (chunks: string) => string;
-/**
- * Reads a dotted `path` (e.g. `counter.label`) out of a nested object value.
- *
- * @param objectValue - The object to read from.
- * @param path - Dot-separated path. An empty path returns `objectValue`.
- * @returns The value found at `path`, or `undefined` when any segment is absent.
- */
-declare const navigatePath: (objectValue: unknown, path: string) => unknown;
 /**
  * The untyped runtime translator shared by `useTranslations` (React hook) and
  * `createTranslator` (non-React core).
@@ -45,7 +37,33 @@ declare const createNamespaceTranslator: (locale: LocalesValues, namespace?: str
    */
   markup: (key: string, values?: Record<string, unknown>) => string;
 };
+/**
+ * Dictionary-bound translator used by the build-optimized `useDictionary` /
+ * `getDictionary` variants: instead of resolving the dictionary by key at
+ * runtime, the pre-resolved content is supplied directly (the babel/swc
+ * optimize pass imports the dictionary JSON at build time).
+ *
+ * @param locale - The locale messages are resolved for.
+ * @param content - The dictionary content, already resolved for `locale`.
+ * @param namespacePrefix - Optional key prefix for nested namespaces
+ *   (`useTranslations('about.counter')` → content of `about`, prefix `counter`).
+ * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.
+ */
+declare const createDictionaryTranslator: (locale: LocalesValues, content: unknown, namespacePrefix?: string) => ((key: string, values?: MessageValues) => string) & {
+  /** Returns `true` if the given key exists in the namespace. */has: (key: string) => boolean; /** Returns the raw unprocessed content for the given key. */
+  raw: (key: string) => unknown;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup, mapping each
+   * tag through the matching renderer in `values`.
+   */
+  rich: (key: string, values?: Record<string, unknown>) => ReactNode;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup into a string,
+   * mapping each tag through the matching string renderer in `values`.
+   */
+  markup: (key: string, values?: Record<string, unknown>) => string;
+};
 type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;
 //#endregion
-export { CompatTranslator, MarkupChunkRenderer, RichChunkRenderer, createNamespaceTranslator, navigatePath };
+export { CompatTranslator, MarkupChunkRenderer, RichChunkRenderer, createDictionaryTranslator, createNamespaceTranslator, navigatePath };
 //# sourceMappingURL=namespaceTranslator.d.ts.map

package/dist/types/shared/namespaceTranslator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"namespaceTranslator.d.ts","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"mappings":";;;;;;KAeY,iBAAA,IAAqB,MAAA,EAAQ,SAAA,KAAc,SAAA;AAAvD;AAAA,KAGY,mBAAA,IAAuB,MAAA;;;;;;;;cAStB,YAAA,GAAgB,WAAA,WAAsB,IAAA;;;;;AAAnD;;;;;AAwGA;;;;;;;cAAa,yBAAA,GACX,MAAA,EAAQ,aAAA,EACR,SAAA,gBAAkB,GAAA,UAyDY,MAAA,GAAW,aAAA;EAyBF,8FAnF/B;;EACR;;;;sBAuEoB,MAAA,GAAW,MAAA,sBAA0B,SAAA;;;;;wBAWnC,MAAA,GAAW,MAAA;AAAA;AAAA,KASvB,gBAAA,GAAmB,UAAA,QAAkB,yBAAA"}
+{"version":3,"file":"namespaceTranslator.d.ts","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"mappings":";;;;;;KAkBY,iBAAA,IAAqB,MAAA,EAAQ,SAAA,KAAc,SAAA;;KAG3C,mBAAA,IAAuB,MAAA;;;;;;;AAAnC;;;;;AA0EA;;;;;cAAa,yBAAA,GACX,MAAA,EAAQ,aAAA,EACR,SAAA,gBAAkB,GAAA,UAgHY,MAAA,GAAW,aAAA;EAcgB,8FAWlB;;EA1I/B;;;;sBA+HY,MAAA,GAAW,MAAA,sBAA0B,SAAA;EAd3B;;;;wBAyBR,MAAA,GAAW,MAAA;AAAA;;;;;;;;;;;AA/DnC;;cAAa,0BAAA,GACX,MAAA,EAAQ,aAAA,EACR,OAAA,WACA,eAAA,gBAAwB,GAAA,UAmCM,MAAA,GAAW,aAAA;EArCjC,8FAmDuB;;EAWE;;;;sBAXb,MAAA,GAAW,MAAA,sBAA0B,SAAA;EAlDzD;;;;wBA6DsB,MAAA,GAAW,MAAA;AAAA;AAAA,KASvB,gBAAA,GAAmB,UAAA,QAAkB,yBAAA"}

package/dist/types/shared/translateFunctionTypes.d.ts

@@ -1,9 +1,26 @@
 import { MarkupChunkRenderer, RichChunkRenderer } from "./namespaceTranslator.js";
 import { DictionaryKeys } from "@intlayer/types/module_augmentation";
 import { ReactNode } from "react";
+import { GetNestingResult } from "@intlayer/core/interpreter";
 import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 
 //#region src/shared/translateFunctionTypes.d.ts
+/**
+ * The interpreter-resolved content type at dot-path `P` of dictionary `N` —
+ * the same type strength as the base `useIntlayer` hook.
+ */
+type ContentAtPath<N extends DictionaryKeys, P> = GetNestingResult<N, P>;
+/**
+ * The value returned by `t()` for key `P` of dictionary `N`: string literals
+ * declared in the dictionary keep their literal type (matching the strength of
+ * `useIntlayer`), every other node resolves to `string` at runtime.
+ */
+type TranslatedValue<N extends DictionaryKeys, P> = ContentAtPath<N, P> extends string ? ContentAtPath<N, P> : string;
+/**
+ * The dot-paths of dictionary `D` relative to the nested namespace scope
+ * `Prefix` (`useTranslations('about.counter')` → paths under `about.counter`).
+ */
+type ScopedDotPaths<D extends DictionaryKeys, Prefix extends string> = ValidDotPathsFor<D> extends infer AllPaths ? AllPaths extends `${Prefix}.${infer RelativePath}` ? RelativePath : never : never;
 /**
  * The translation function returned for a bare dictionary key namespace.
  *
@@ -15,13 +32,32 @@ import { ValidDotPathsFor } from "@intlayer/core/transpiler";
  * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.
  */
 type TranslateFunction<N extends DictionaryKeys> = {
-  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): string; /** Returns `true` if the given key exists in the namespace. */
+  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): TranslatedValue<N, P>; /** Returns `true` if the given key exists in the namespace. */
   has<P extends ValidDotPathsFor<N>>(key: P): boolean; /** Returns the raw unprocessed content for the given key. */
-  raw<P extends ValidDotPathsFor<N>>(key: P): unknown; /** Resolves rich-text markup, mapping tags through React renderers. */
+  raw<P extends ValidDotPathsFor<N>>(key: P): ContentAtPath<N, P>; /** Resolves rich-text markup, mapping tags through React renderers. */
   rich<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
   markup<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
 };
-/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */
+/**
+ * The translation function returned for a nested `'dictionary.scope'`
+ * namespace: keys are relative dot-paths under the scope, and return types are
+ * resolved against the absolute path in the dictionary.
+ */
+type ScopedTranslateFunction<D extends DictionaryKeys, Prefix extends string> = {
+  /** Translate a scoped key to a string, with optional ICU interpolation params. */<P extends ScopedDotPaths<D, Prefix>>(key: P, params?: Record<string, unknown>): TranslatedValue<D, `${Prefix}.${P}`>; /** Returns `true` if the given key exists in the scoped namespace. */
+  has<P extends ScopedDotPaths<D, Prefix>>(key: P): boolean; /** Returns the raw unprocessed content for the given scoped key. */
+  raw<P extends ScopedDotPaths<D, Prefix>>(key: P): ContentAtPath<D, `${Prefix}.${P}`>; /** Resolves rich-text markup, mapping tags through React renderers. */
+  rich<P extends ScopedDotPaths<D, Prefix>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
+  markup<P extends ScopedDotPaths<D, Prefix>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/**
+ * Resolves the translation function type for a namespace argument: a bare
+ * dictionary key keeps the fully-typed dot-paths, a nested
+ * `'dictionary.scope'` namespace is split at the first dot and typed
+ * relative to the scope, anything else falls back to loose typing.
+ */
+type TranslateFunctionForNamespace<N extends string> = N extends DictionaryKeys ? TranslateFunction<N> : N extends `${infer D extends DictionaryKeys & string}.${infer Prefix}` ? ScopedTranslateFunction<D, Prefix> : LooseTranslateFunction;
+/** Loosely-typed function returned for untyped namespaces (root scope). */
 type LooseTranslateFunction = {
   (key: string, params?: Record<string, unknown>): string;
   has(key: string): boolean;
@@ -30,5 +66,5 @@ type LooseTranslateFunction = {
   markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
 };
 //#endregion
-export { LooseTranslateFunction, TranslateFunction };
+export { ContentAtPath, LooseTranslateFunction, ScopedDotPaths, ScopedTranslateFunction, TranslateFunction, TranslateFunctionForNamespace, TranslatedValue };
 //# sourceMappingURL=translateFunctionTypes.d.ts.map

package/dist/types/shared/translateFunctionTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translateFunctionTypes.d.ts","names":[],"sources":["../../../src/shared/translateFunctionTypes.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;KAAY,iBAAA,WAA4B,cAAA;EAOxB,sFALH,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAKoB;EAF/B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAEA;EAAxC,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAEzB;EAAf,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EADuB;EAG1B,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;KAKhB,sBAAA;EAAA,CACT,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA"}
+{"version":3,"file":"translateFunctionTypes.d.ts","names":[],"sources":["../../../src/shared/translateFunctionTypes.ts"],"mappings":";;;;;;;;;AAaA;;KAAY,aAAA,WAAwB,cAAA,OAAqB,gBAAA,CAAiB,CAAA,EAAG,CAAA;;;;;;KAOjE,eAAA,WAA0B,cAAA,OACpC,aAAA,CAAc,CAAA,EAAG,CAAA,mBAAoB,aAAA,CAAc,CAAA,EAAG,CAAA;;;;;KAM5C,cAAA,WAAyB,cAAA,2BACnC,gBAAA,CAAiB,CAAA,2BACb,QAAA,YAAoB,MAAA,2BAClB,YAAA;;;;AAVR;;;;;;;KAwBY,iBAAA,WAA4B,cAAA;EAvBgB,sFAyB3C,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,oBACR,eAAA,CAAgB,CAAA,EAAG,CAAA,GA5B4B;EA8BlD,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YA/Bd;EAiC1B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,GAAI,aAAA,CAAc,CAAA,EAAG,CAAA,GAjCT;EAmCpD,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EArCW;EAuCd,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;;;;AAnC5B;KA4CY,uBAAA,WACA,cAAA;EA7Cc,6FAiDb,cAAA,CAAe,CAAA,EAAG,MAAA,GAC3B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,oBACR,eAAA,CAAgB,CAAA,KAAM,MAAA,IAAU,CAAA,KAnDlB;EAqDjB,GAAA,WAAc,cAAA,CAAe,CAAA,EAAG,MAAA,GAAS,GAAA,EAAK,CAAA,YApDtB;EAsDxB,GAAA,WAAc,cAAA,CAAe,CAAA,EAAG,MAAA,GAC9B,GAAA,EAAK,CAAA,GACJ,aAAA,CAAc,CAAA,KAAM,MAAA,IAAU,CAAA,KAxDH;EA0D9B,IAAA,WAAe,cAAA,CAAe,CAAA,EAAG,MAAA,GAC/B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EA/DgC;EAiEnC,MAAA,WAAiB,cAAA,CAAe,CAAA,EAAG,MAAA,GACjC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;;;;;;KAUhB,6BAAA,qBACV,CAAA,SAAU,cAAA,GACN,iBAAA,CAAkB,CAAA,IAClB,CAAA,4BAA6B,cAAA,8BAC3B,uBAAA,CAAwB,CAAA,EAAG,MAAA,IAC3B,sBAAA;;KAGI,sBAAA;EAAA,CACT,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA"}

package/dist/types/useDictionary.d.ts

@@ -1,7 +1,17 @@
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { ScopedTranslateFunction, TranslateFunction } from "./shared/translateFunctionTypes.js";
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
 
 //#region src/useDictionary.d.ts
+/**
+ * Overload set for {@link useDictionary}: without a prefix the translator is
+ * typed against the dictionary's dot-paths; with a prefix the keys are
+ * relative dot-paths under that scope.
+ */
+type UseDictionary = {
+  <T extends Dictionary>(dictionary: T): TranslateFunction<T['key'] & DictionaryKeys>;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, namespacePrefix: Prefix): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;
+};
 /**
  * Dictionary-accepting variant of `useTranslations`.
  *
@@ -10,14 +20,14 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * JSON at build time and passes it directly here. This enables tree-shaking of
  * unused locale content.
  *
+ * The returned translator matches `useTranslations` exactly (ICU messages,
+ * `has`, `raw`, `rich`, `markup`).
+ *
  * @example (generated by the plugin, not written manually)
  * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
  * const t = useDictionary(_abc);
  */
-declare const useDictionary: <T extends Dictionary>(dictionary: T, namespacePrefix?: string) => (<P extends ValidDotPathsFor<string>>(lookup: P, params?: Record<string, unknown>) => string) & {
-  has: <P extends ValidDotPathsFor<string>>(lookup: P) => boolean;
-  raw: <P extends ValidDotPathsFor<string>>(lookup: P) => unknown;
-};
+declare const useDictionary: UseDictionary;
 //#endregion
 export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;cAAa,aAAA,aAA2B,UAAA,EACtC,UAAA,EAAY,CAAA,EACZ,eAAA,0BAQa,gBAAA,UAAwB,MAAA,EACzB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,UAAwB,MAAA,EAAU,CAAA;kBAElC,gBAAA,UAAwB,MAAA,EAAU,CAAA;AAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;AAgByC;;;KAOpC,aAAA;EAAA,WACQ,UAAA,EACT,UAAA,EAAY,CAAA,GACX,iBAAA,CAAkB,CAAA,UAAW,cAAA;EAAA,WACrB,UAAA,yBACT,UAAA,EAAY,CAAA,EACZ,eAAA,EAAiB,MAAA,GAChB,uBAAA,CAAwB,CAAA,UAAW,cAAA,EAAgB,MAAA;AAAA;;;;;;;;;;;;;;;;cAkB3C,aAAA,EAYP,aAAA"}

package/dist/types/useDictionaryDynamic.d.ts

@@ -1,18 +1,24 @@
-import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { ScopedTranslateFunction, TranslateFunction } from "./shared/translateFunctionTypes.js";
+import { DictionaryKeys, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
 
 //#region src/useDictionaryDynamic.d.ts
+/**
+ * Overload set for {@link useDictionaryDynamic}: without a prefix the
+ * translator is typed against the dictionary's dot-paths; with a prefix the
+ * keys are relative dot-paths under that scope.
+ */
+type UseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K): TranslateFunction<K>;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, namespacePrefix: Prefix): ScopedTranslateFunction<K, Prefix>;
+};
 /**
  * Dynamic dictionary-accepting variant of `useTranslations`.
  *
  * Counterpart to {@link useDictionary} for dictionaries imported lazily per
  * locale. Used internally by the build-time optimization.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends string>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, namespacePrefix?: string) => (<P extends ValidDotPathsFor<string>>(lookup: P, params?: Record<string, unknown>) => string) & {
-  has: <P extends ValidDotPathsFor<string>>(lookup: P) => boolean;
-  raw: <P extends ValidDotPathsFor<string>>(lookup: P) => unknown;
-};
+declare const useDictionaryDynamic: UseDictionaryDynamic;
 //#endregion
 export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;AAcA;;;;cAAa,oBAAA,mBACK,UAAA,0BAGhB,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,eAAA,0BAQa,gBAAA,UAAwB,MAAA,EACzB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,UAAwB,MAAA,EAAU,CAAA;kBAElC,gBAAA,UAAwB,MAAA,EAAU,CAAA;AAAA"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;AAiByC;;;KAOpC,oBAAA;EAAA,WACQ,UAAA,YAAsB,cAAA,EAC/B,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,GACJ,iBAAA,CAAkB,CAAA;EAAA,WACV,UAAA,YAAsB,cAAA,yBAC/B,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,eAAA,EAAiB,MAAA,GAChB,uBAAA,CAAwB,CAAA,EAAG,MAAA;AAAA;;;;;;;cASnB,oBAAA,EAgBP,oBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/use-intl",
-  "version": "9.0.0-canary.10",
+  "version": "9.0.0-canary.12",
   "private": false,
   "description": "use-intl API adapter for intlayer — useTranslations, useLocale, useFormatter, IntlProvider, createTranslator backed by react-intlayer",
   "keywords": [
@@ -89,13 +89,13 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/chokidar": "9.0.0-canary.10",
-    "@intlayer/config": "9.0.0-canary.10",
-    "@intlayer/core": "9.0.0-canary.10",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.10",
-    "@intlayer/types": "9.0.0-canary.10",
-    "react-intlayer": "9.0.0-canary.10",
-    "vite-intlayer": "9.0.0-canary.10"
+    "@intlayer/config": "9.0.0-canary.12",
+    "@intlayer/core": "9.0.0-canary.12",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.12",
+    "@intlayer/engine": "9.0.0-canary.12",
+    "@intlayer/types": "9.0.0-canary.12",
+    "react-intlayer": "9.0.0-canary.12",
+    "vite-intlayer": "9.0.0-canary.12"
   },
   "devDependencies": {
     "@types/node": "25.9.4",
@@ -107,7 +107,7 @@
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
     "use-intl": "4.13.0",
-    "vite": "8.1.0",
+    "vite": "8.1.2",
     "vitest": "4.1.9"
   },
   "peerDependencies": {