react-intlayer 9.3.2 → 9.3.3

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -40,6 +40,8 @@ const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector) => {
 		loadChunk: (cacheKey, promise) => require_client_useLoadDynamic.useLoadDynamic(cacheKey, promise),
 		transform: (dictionary) => require_getDictionary.getDictionary(dictionary, localeTarget)
 	});
+	const preloadedDictionary = (0, _intlayer_core_dictionaryManipulator.getPreloadedDictionary)(dictionaryPromise, localeTarget);
+	if (preloadedDictionary) return require_getDictionary.getDictionary(preloadedDictionary, localeTarget);
 	const plainLoaders = dictionaryPromise;
 	const dictionary = require_client_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.());
 	return require_getDictionary.getDictionary(dictionary, localeTarget);

package/dist/cjs/client/useDictionaryDynamic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["useContext","IntlayerClientContext","parseDictionarySelector","resolveDictionaryArgument","internationalization","isQualifiedDynamicLoaderMap","resolveQualifiedDynamicContent","loadDynamicChunk","getDictionary"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,uBACtCA,kBAAWC,qDAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,cACzCC,kEAGEC,gEAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiBC,4CAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,eAC7CC,kEAA4B,iBAAiB,GAE7C,WAAOC,qEAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,OAAO;EACpE,YAAY,eAAeC,oCAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CAIrB,MAAM,aAAaD,6CACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAOC,oCAAc,YAAY,YAAY;AAC/C"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["useContext","IntlayerClientContext","parseDictionarySelector","resolveDictionaryArgument","internationalization","isQualifiedDynamicLoaderMap","resolveQualifiedDynamicContent","loadDynamicChunk","getDictionary","getPreloadedDictionary"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  getPreloadedDictionary,\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  // A build-tool plugin may have started this locale's chunk while the entry\n  // point itself was evaluating, in which case the content is already here and\n  // reading it must not go through the suspender — see `getPreloadedDictionary`.\n  const preloadedDictionary = getPreloadedDictionary(\n    dictionaryPromise,\n    localeTarget\n  );\n  if (preloadedDictionary) {\n    return getDictionary(preloadedDictionary as T, localeTarget);\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,uBACtCA,kBAAWC,qDAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,cACzCC,kEAGEC,gEAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiBC,4CAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,eAC7CC,kEAA4B,iBAAiB,GAE7C,WAAOC,qEAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYC,6CAAiB,UAAU,OAAO;EACpE,YAAY,eAAeC,oCAAc,YAAY,YAAY;CACnE,CAAC;CAMH,MAAM,0BAAsBC,6DAC1B,mBACA,YACF;CACA,IAAI,qBACF,OAAOD,oCAAc,qBAA0B,YAAY;CAG7D,MAAM,eAAe;CAIrB,MAAM,aAAaD,6CACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAOC,oCAAc,YAAY,YAAY;AAC/C"}

package/dist/cjs/client/useLoadDynamic.cjs

@@ -10,18 +10,45 @@ const createSuspender = (promise) => {
 		status = "error";
 		result = e;
 	});
-	return { read() {
-		if (status === "pending") throw suspender;
-		if (status === "error") throw result;
-		return result;
-	} };
+	return {
+		settled: suspender,
+		read() {
+			if (status === "pending") throw suspender;
+			if (status === "error") throw result;
+			return result;
+		}
+	};
 };
 const cache = /* @__PURE__ */ new Map();
 const useLoadDynamic = (key, promise) => {
 	if (!cache.has(key)) cache.set(key, createSuspender(promise));
 	return cache.get(key).read();
 };
+/**
+* Fills the same cache {@link useLoadDynamic} reads, ahead of render.
+*
+* A component that reads a dictionary during render suspends whenever the entry
+* is still `pending`, and the nearest boundary shows its fallback. Awaiting this
+* before the render — in a router loader, or during app startup — makes that
+* read synchronous, so no boundary ever falls back.
+*
+* Handing over an already-resolved promise is not enough on its own:
+* {@link createSuspender} only leaves `pending` inside a `.then` callback, so
+* the first read would still suspend for one microtask. Awaiting the returned
+* promise resolves that race, because the callback registered by
+* `createSuspender` runs before this one.
+*
+* @param key - Cache key, identical to the one the later read uses.
+* @param loader - Invoked only when the key is not cached yet, so preloading a
+*                 dictionary twice never issues a second request.
+* @returns A promise that settles — never rejects — once the entry is readable.
+*/
+const preloadDynamic = (key, loader) => {
+	if (!cache.has(key)) cache.set(key, createSuspender(loader()));
+	return cache.get(key).settled;
+};
 
 //#endregion
+exports.preloadDynamic = preloadDynamic;
 exports.useLoadDynamic = useLoadDynamic;
 //# sourceMappingURL=useLoadDynamic.cjs.map

package/dist/cjs/client/useLoadDynamic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.cjs","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"sourcesContent":["type Status = 'pending' | 'success' | 'error';\n\nconst createSuspender = <T>(promise: Promise<T>) => {\n  let status: Status = 'pending';\n  let result: T;\n  const suspender = promise.then(\n    (r) => {\n      status = 'success';\n      result = r;\n    },\n    (e) => {\n      status = 'error';\n      result = e as any;\n    }\n  );\n\n  return {\n    read() {\n      if (status === 'pending') throw suspender;\n      if (status === 'error') throw result;\n      return result!;\n    },\n  };\n};\n\nconst cache = new Map<string, ReturnType<typeof createSuspender>>();\n\nexport const useLoadDynamic = <T>(key: string, promise: Promise<T>): T => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(promise));\n  }\n\n  return (cache.get(key)! as ReturnType<typeof createSuspender>).read() as T;\n};\n"],"mappings":";;AAEA,MAAM,mBAAsB,YAAwB;CAClD,IAAI,SAAiB;CACrB,IAAI;CACJ,MAAM,YAAY,QAAQ,MACvB,MAAM;EACL,SAAS;EACT,SAAS;CACX,IACC,MAAM;EACL,SAAS;EACT,SAAS;CACX,CACF;CAEA,OAAO,EACL,OAAO;EACL,IAAI,WAAW,WAAW,MAAM;EAChC,IAAI,WAAW,SAAS,MAAM;EAC9B,OAAO;CACT,EACF;AACF;AAEA,MAAM,wBAAQ,IAAI,IAAgD;AAElE,MAAa,kBAAqB,KAAa,YAA2B;CACxE,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC;CAGzC,OAAQ,MAAM,IAAI,GAAG,CAAC,CAAyC,KAAK;AACtE"}
+{"version":3,"file":"useLoadDynamic.cjs","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"sourcesContent":["type Status = 'pending' | 'success' | 'error';\n\ntype Suspender<T> = {\n  /**\n   * Settles once the entry has left `pending`, never rejecting. Awaiting it\n   * guarantees a subsequent {@link Suspender.read} returns without suspending.\n   */\n  settled: Promise<void>;\n  read: () => T;\n};\n\nconst createSuspender = <T>(promise: Promise<T>): Suspender<T> => {\n  let status: Status = 'pending';\n  let result: T;\n  const suspender = promise.then(\n    (r) => {\n      status = 'success';\n      result = r;\n    },\n    (e) => {\n      status = 'error';\n      result = e as any;\n    }\n  );\n\n  return {\n    settled: suspender,\n    read() {\n      if (status === 'pending') throw suspender;\n      if (status === 'error') throw result;\n      return result!;\n    },\n  };\n};\n\nconst cache = new Map<string, Suspender<unknown>>();\n\nexport const useLoadDynamic = <T>(key: string, promise: Promise<T>): T => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(promise));\n  }\n\n  return (cache.get(key)! as Suspender<T>).read() as T;\n};\n\n/**\n * Fills the same cache {@link useLoadDynamic} reads, ahead of render.\n *\n * A component that reads a dictionary during render suspends whenever the entry\n * is still `pending`, and the nearest boundary shows its fallback. Awaiting this\n * before the render — in a router loader, or during app startup — makes that\n * read synchronous, so no boundary ever falls back.\n *\n * Handing over an already-resolved promise is not enough on its own:\n * {@link createSuspender} only leaves `pending` inside a `.then` callback, so\n * the first read would still suspend for one microtask. Awaiting the returned\n * promise resolves that race, because the callback registered by\n * `createSuspender` runs before this one.\n *\n * @param key - Cache key, identical to the one the later read uses.\n * @param loader - Invoked only when the key is not cached yet, so preloading a\n *                 dictionary twice never issues a second request.\n * @returns A promise that settles — never rejects — once the entry is readable.\n */\nexport const preloadDynamic = <T>(\n  key: string,\n  loader: () => Promise<T>\n): Promise<void> => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(loader()) as Suspender<unknown>);\n  }\n\n  return cache.get(key)!.settled;\n};\n"],"mappings":";;AAWA,MAAM,mBAAsB,YAAsC;CAChE,IAAI,SAAiB;CACrB,IAAI;CACJ,MAAM,YAAY,QAAQ,MACvB,MAAM;EACL,SAAS;EACT,SAAS;CACX,IACC,MAAM;EACL,SAAS;EACT,SAAS;CACX,CACF;CAEA,OAAO;EACL,SAAS;EACT,OAAO;GACL,IAAI,WAAW,WAAW,MAAM;GAChC,IAAI,WAAW,SAAS,MAAM;GAC9B,OAAO;EACT;CACF;AACF;AAEA,MAAM,wBAAQ,IAAI,IAAgC;AAElD,MAAa,kBAAqB,KAAa,YAA2B;CACxE,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC;CAGzC,OAAQ,MAAM,IAAI,GAAG,CAAC,CAAmB,KAAK;AAChD;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,kBACX,KACA,WACkB;CAClB,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC,CAAuB;CAGhE,OAAO,MAAM,IAAI,GAAG,CAAC,CAAE;AACzB"}

package/dist/esm/client/useDictionaryDynamic.mjs

@@ -5,7 +5,7 @@ import { getDictionary } from "../getDictionary.mjs";
 import { IntlayerClientContext } from "./IntlayerProvider.mjs";
 import { internationalization } from "@intlayer/config/built";
 import { useContext } from "react";
-import { isQualifiedDynamicLoaderMap, parseDictionarySelector, resolveDictionaryArgument, resolveQualifiedDynamicContent } from "@intlayer/core/dictionaryManipulator";
+import { getPreloadedDictionary, isQualifiedDynamicLoaderMap, parseDictionarySelector, resolveDictionaryArgument, resolveQualifiedDynamicContent } from "@intlayer/core/dictionaryManipulator";
 
 //#region src/client/useDictionaryDynamic.ts
 /**
@@ -39,6 +39,8 @@ const useDictionaryDynamic = (dictionaryPromise, key, localeOrSelector) => {
 		loadChunk: (cacheKey, promise) => useLoadDynamic(cacheKey, promise),
 		transform: (dictionary) => getDictionary(dictionary, localeTarget)
 	});
+	const preloadedDictionary = getPreloadedDictionary(dictionaryPromise, localeTarget);
+	if (preloadedDictionary) return getDictionary(preloadedDictionary, localeTarget);
 	const plainLoaders = dictionaryPromise;
 	const dictionary = useLoadDynamic(`${String(key)}.${localeTarget}`, plainLoaders[localeTarget]?.());
 	return getDictionary(dictionary, localeTarget);

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":["loadDynamicChunk"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,UACzC,wBAGE,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiB,qBAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,WAC7C,4BAA4B,iBAAiB,GAE7C,OAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,OAAO;EACpE,YAAY,eAAe,cAAc,YAAY,YAAY;CACnE,CAAC;CAGH,MAAM,eAAe;CAIrB,MAAM,aAAaA,eACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAO,cAAc,YAAY,YAAY;AAC/C"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["loadDynamicChunk"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { internationalization } from '@intlayer/config/built';\nimport {\n  getPreloadedDictionary,\n  isQualifiedDynamicLoaderMap,\n  parseDictionarySelector,\n  type QualifiedDynamicLoaderMap,\n  resolveDictionaryArgument,\n  resolveQualifiedDynamicContent,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionarySelectorForKey,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n// `useLoadDynamic` is a suspender cache, not a React hook — aliased to a\n// non-hook name so it can be invoked in loops / conditionally (e.g. when a\n// collection loads several chunks at once).\nimport { useLoadDynamic as loadDynamicChunk } from './useLoadDynamic';\n\n/**\n * Client-side hook that lazily loads a dictionary and returns its content.\n *\n * The dictionary entry is either a plain dynamic loader map\n * (`locale → loader`) or a qualified one (`locale → qualifierId → loader`,\n * tagged with the qualifier dimension). For qualified maps, only the chunk(s)\n * the selector targets are loaded; the resolution mirrors static mode.\n *\n * If the locale is not provided (directly or through the selector), the client\n * context locale is used.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales,\n>(\n  dictionaryPromise:\n    | StrictModeLocaleMap<() => Promise<T>>\n    | QualifiedDynamicLoaderMap,\n  key: K,\n  localeOrSelector?: A\n) => {\n  const { locale: currentLocale, variant: contextVariant } =\n    useContext(IntlayerClientContext) ?? {};\n\n  const { locale: selectorLocale, selector } =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false'\n      ? parseDictionarySelector<LocalesValues>(\n          // Layers the provider's ambient variant under the call-site argument\n          // before the chunk walk, so only the targeted chunk is loaded.\n          resolveDictionaryArgument({\n            localeOrSelector,\n            contextLocale: currentLocale,\n            contextVariant,\n            dictionaryKey: String(key),\n          })\n        )\n      : {\n          locale: localeOrSelector as LocalesValues | undefined,\n          selector: undefined,\n        };\n\n  const localeTarget =\n    selectorLocale ?? currentLocale ?? internationalization.defaultLocale;\n\n  if (\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryPromise)\n  ) {\n    return resolveQualifiedDynamicContent({\n      loaderMap: dictionaryPromise,\n      key: String(key),\n      locale: localeTarget,\n      selector,\n      loadChunk: (cacheKey, promise) => loadDynamicChunk(cacheKey, promise),\n      transform: (dictionary) => getDictionary(dictionary, localeTarget),\n    });\n  }\n\n  // A build-tool plugin may have started this locale's chunk while the entry\n  // point itself was evaluating, in which case the content is already here and\n  // reading it must not go through the suspender — see `getPreloadedDictionary`.\n  const preloadedDictionary = getPreloadedDictionary(\n    dictionaryPromise,\n    localeTarget\n  );\n  if (preloadedDictionary) {\n    return getDictionary(preloadedDictionary as T, localeTarget);\n  }\n\n  const plainLoaders = dictionaryPromise as StrictModeLocaleMap<\n    () => Promise<T>\n  >;\n\n  const dictionary = loadDynamicChunk<T>(\n    `${String(key)}.${localeTarget}`,\n    plainLoaders[localeTarget as keyof typeof plainLoaders]?.() as Promise<T>\n  );\n\n  return getDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,wBAKX,mBAGA,KACA,qBACG;CACH,MAAM,EAAE,QAAQ,eAAe,SAAS,mBACtC,WAAW,qBAAqB,KAAK,CAAC;CAExC,MAAM,EAAE,QAAQ,gBAAgB,aAC9B,QAAQ,IAAI,iCAAiC,UACzC,wBAGE,0BAA0B;EACxB;EACA,eAAe;EACf;EACA,eAAe,OAAO,GAAG;CAC3B,CAAC,CACH,IACA;EACE,QAAQ;EACR,UAAU;CACZ;CAEN,MAAM,eACJ,kBAAkB,iBAAiB,qBAAqB;CAE1D,IACE,QAAQ,IAAI,iCAAiC,WAC7C,4BAA4B,iBAAiB,GAE7C,OAAO,+BAA+B;EACpC,WAAW;EACX,KAAK,OAAO,GAAG;EACf,QAAQ;EACR;EACA,YAAY,UAAU,YAAYA,eAAiB,UAAU,OAAO;EACpE,YAAY,eAAe,cAAc,YAAY,YAAY;CACnE,CAAC;CAMH,MAAM,sBAAsB,uBAC1B,mBACA,YACF;CACA,IAAI,qBACF,OAAO,cAAc,qBAA0B,YAAY;CAG7D,MAAM,eAAe;CAIrB,MAAM,aAAaA,eACjB,GAAG,OAAO,GAAG,EAAE,GAAG,gBAClB,aAAa,aAA0C,GAAG,CAC5D;CAEA,OAAO,cAAc,YAAY,YAAY;AAC/C"}

package/dist/esm/client/useLoadDynamic.mjs

@@ -9,18 +9,44 @@ const createSuspender = (promise) => {
 		status = "error";
 		result = e;
 	});
-	return { read() {
-		if (status === "pending") throw suspender;
-		if (status === "error") throw result;
-		return result;
-	} };
+	return {
+		settled: suspender,
+		read() {
+			if (status === "pending") throw suspender;
+			if (status === "error") throw result;
+			return result;
+		}
+	};
 };
 const cache = /* @__PURE__ */ new Map();
 const useLoadDynamic = (key, promise) => {
 	if (!cache.has(key)) cache.set(key, createSuspender(promise));
 	return cache.get(key).read();
 };
+/**
+* Fills the same cache {@link useLoadDynamic} reads, ahead of render.
+*
+* A component that reads a dictionary during render suspends whenever the entry
+* is still `pending`, and the nearest boundary shows its fallback. Awaiting this
+* before the render — in a router loader, or during app startup — makes that
+* read synchronous, so no boundary ever falls back.
+*
+* Handing over an already-resolved promise is not enough on its own:
+* {@link createSuspender} only leaves `pending` inside a `.then` callback, so
+* the first read would still suspend for one microtask. Awaiting the returned
+* promise resolves that race, because the callback registered by
+* `createSuspender` runs before this one.
+*
+* @param key - Cache key, identical to the one the later read uses.
+* @param loader - Invoked only when the key is not cached yet, so preloading a
+*                 dictionary twice never issues a second request.
+* @returns A promise that settles — never rejects — once the entry is readable.
+*/
+const preloadDynamic = (key, loader) => {
+	if (!cache.has(key)) cache.set(key, createSuspender(loader()));
+	return cache.get(key).settled;
+};
 
 //#endregion
-export { useLoadDynamic };
+export { preloadDynamic, useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.mjs","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"sourcesContent":["type Status = 'pending' | 'success' | 'error';\n\nconst createSuspender = <T>(promise: Promise<T>) => {\n  let status: Status = 'pending';\n  let result: T;\n  const suspender = promise.then(\n    (r) => {\n      status = 'success';\n      result = r;\n    },\n    (e) => {\n      status = 'error';\n      result = e as any;\n    }\n  );\n\n  return {\n    read() {\n      if (status === 'pending') throw suspender;\n      if (status === 'error') throw result;\n      return result!;\n    },\n  };\n};\n\nconst cache = new Map<string, ReturnType<typeof createSuspender>>();\n\nexport const useLoadDynamic = <T>(key: string, promise: Promise<T>): T => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(promise));\n  }\n\n  return (cache.get(key)! as ReturnType<typeof createSuspender>).read() as T;\n};\n"],"mappings":";AAEA,MAAM,mBAAsB,YAAwB;CAClD,IAAI,SAAiB;CACrB,IAAI;CACJ,MAAM,YAAY,QAAQ,MACvB,MAAM;EACL,SAAS;EACT,SAAS;CACX,IACC,MAAM;EACL,SAAS;EACT,SAAS;CACX,CACF;CAEA,OAAO,EACL,OAAO;EACL,IAAI,WAAW,WAAW,MAAM;EAChC,IAAI,WAAW,SAAS,MAAM;EAC9B,OAAO;CACT,EACF;AACF;AAEA,MAAM,wBAAQ,IAAI,IAAgD;AAElE,MAAa,kBAAqB,KAAa,YAA2B;CACxE,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC;CAGzC,OAAQ,MAAM,IAAI,GAAG,CAAC,CAAyC,KAAK;AACtE"}
+{"version":3,"file":"useLoadDynamic.mjs","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"sourcesContent":["type Status = 'pending' | 'success' | 'error';\n\ntype Suspender<T> = {\n  /**\n   * Settles once the entry has left `pending`, never rejecting. Awaiting it\n   * guarantees a subsequent {@link Suspender.read} returns without suspending.\n   */\n  settled: Promise<void>;\n  read: () => T;\n};\n\nconst createSuspender = <T>(promise: Promise<T>): Suspender<T> => {\n  let status: Status = 'pending';\n  let result: T;\n  const suspender = promise.then(\n    (r) => {\n      status = 'success';\n      result = r;\n    },\n    (e) => {\n      status = 'error';\n      result = e as any;\n    }\n  );\n\n  return {\n    settled: suspender,\n    read() {\n      if (status === 'pending') throw suspender;\n      if (status === 'error') throw result;\n      return result!;\n    },\n  };\n};\n\nconst cache = new Map<string, Suspender<unknown>>();\n\nexport const useLoadDynamic = <T>(key: string, promise: Promise<T>): T => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(promise));\n  }\n\n  return (cache.get(key)! as Suspender<T>).read() as T;\n};\n\n/**\n * Fills the same cache {@link useLoadDynamic} reads, ahead of render.\n *\n * A component that reads a dictionary during render suspends whenever the entry\n * is still `pending`, and the nearest boundary shows its fallback. Awaiting this\n * before the render — in a router loader, or during app startup — makes that\n * read synchronous, so no boundary ever falls back.\n *\n * Handing over an already-resolved promise is not enough on its own:\n * {@link createSuspender} only leaves `pending` inside a `.then` callback, so\n * the first read would still suspend for one microtask. Awaiting the returned\n * promise resolves that race, because the callback registered by\n * `createSuspender` runs before this one.\n *\n * @param key - Cache key, identical to the one the later read uses.\n * @param loader - Invoked only when the key is not cached yet, so preloading a\n *                 dictionary twice never issues a second request.\n * @returns A promise that settles — never rejects — once the entry is readable.\n */\nexport const preloadDynamic = <T>(\n  key: string,\n  loader: () => Promise<T>\n): Promise<void> => {\n  if (!cache.has(key)) {\n    cache.set(key, createSuspender(loader()) as Suspender<unknown>);\n  }\n\n  return cache.get(key)!.settled;\n};\n"],"mappings":";AAWA,MAAM,mBAAsB,YAAsC;CAChE,IAAI,SAAiB;CACrB,IAAI;CACJ,MAAM,YAAY,QAAQ,MACvB,MAAM;EACL,SAAS;EACT,SAAS;CACX,IACC,MAAM;EACL,SAAS;EACT,SAAS;CACX,CACF;CAEA,OAAO;EACL,SAAS;EACT,OAAO;GACL,IAAI,WAAW,WAAW,MAAM;GAChC,IAAI,WAAW,SAAS,MAAM;GAC9B,OAAO;EACT;CACF;AACF;AAEA,MAAM,wBAAQ,IAAI,IAAgC;AAElD,MAAa,kBAAqB,KAAa,YAA2B;CACxE,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC;CAGzC,OAAQ,MAAM,IAAI,GAAG,CAAC,CAAmB,KAAK;AAChD;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,kBACX,KACA,WACkB;CAClB,IAAI,CAAC,MAAM,IAAI,GAAG,GAChB,MAAM,IAAI,KAAK,gBAAgB,OAAO,CAAC,CAAuB;CAGhE,OAAO,MAAM,IAAI,GAAG,CAAC,CAAE;AACzB"}

package/dist/types/client/format/useCompact.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useCompact.d.ts
 /**
  * React client hook that provides a compact number formatter
@@ -10,7 +11,7 @@
  * ```
  */
 declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useCompact };

package/dist/types/client/format/useCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/client/format/useCompact.ts"],"mappings":";;;;;;;;;;;cAgBa,mBAAU,wBAAA,UAAA,KAAA"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/client/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAgBa,mBAAU,wBAAA,UAAA,KAAA;WAAA"}

package/dist/types/client/format/useCurrency.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useCurrency.d.ts
 /**
  * React client hook that provides a currency formatter
@@ -24,7 +25,7 @@
  * ```
  */
 declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useCurrency };

package/dist/types/client/format/useCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/client/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cA8Ba,oBAAW,wBAAA,UAAA,KAAA"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/client/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ba,oBAAW,wBAAA,UAAA,KAAA;WAAA"}

package/dist/types/client/format/useList.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useList.d.ts
 /**
  * React client hook that provides a list formatter
@@ -25,7 +26,7 @@ declare const useList: () => (values: (string | number)[], options?: {
   type?: 'conjunction' | 'disjunction' | 'unit';
   style?: 'long' | 'short' | 'narrow';
 } & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useList };

package/dist/types/client/format/useList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/client/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cA2Ba,gBAAO,6BAAA"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/client/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA2Ba,gBAAO,6BAAA;;;;;WAAP"}

package/dist/types/client/format/useNumber.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useNumber.d.ts
 /**
  * React client hook that provides a localized number formatter.
@@ -22,7 +23,7 @@
  * A number formatting function bound to the active locale.
  */
 declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useNumber };

package/dist/types/client/format/useNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA4Ba,kBAAS,wBAAA,SAAA,KAAA"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA4Ba,kBAAS,wBAAA,SAAA,KAAA;WAAA"}

package/dist/types/client/format/usePercentage.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/usePercentage.d.ts
 /**
  * React hook to provide a percentage formatter function
@@ -18,7 +19,7 @@
  * A function that formats numbers or numeric strings into localized percentages.
  */
 declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { usePercentage };

package/dist/types/client/format/usePercentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAwBa,sBAAa,wBAAA,SAAA,KAAA"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa,sBAAa,wBAAA,SAAA,KAAA;WAAA"}

package/dist/types/client/format/useRelativeTime.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useRelativeTime.d.ts
 /**
  * Client-side React hook for accessing a localized relative time formatter.
@@ -18,7 +19,7 @@
  *          bound to the current client locale.
  */
 declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
 //#endregion

package/dist/types/client/format/useRelativeTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAwBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA;WAAA"}

package/dist/types/client/format/useUnit.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useUnit.d.ts
 /**
  * React hook that provides a unit formatting function
@@ -17,7 +18,7 @@
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
 declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: import("@intlayer/types").LocalesValues;
+  locale?: LocalesValues;
 }) => string;
 //#endregion
 export { useUnit };

package/dist/types/client/format/useUnit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAuBa,gBAAO,wBAAA,UAAA,KAAA"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuBa,gBAAO,wBAAA,UAAA,KAAA;WAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAqCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAsCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}

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

@@ -1,7 +1,7 @@
 import { DeepTransformContent } from "../plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 import { GetSubPath } from "@intlayer/types/dictionary";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 //#region src/client/useI18n.d.ts
 /**
  * Hook that provides a translation function `t()` for accessing nested content by key.

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

@@ -1,5 +1,25 @@
 //#region src/client/useLoadDynamic.d.ts
 declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
+/**
+ * Fills the same cache {@link useLoadDynamic} reads, ahead of render.
+ *
+ * A component that reads a dictionary during render suspends whenever the entry
+ * is still `pending`, and the nearest boundary shows its fallback. Awaiting this
+ * before the render — in a router loader, or during app startup — makes that
+ * read synchronous, so no boundary ever falls back.
+ *
+ * Handing over an already-resolved promise is not enough on its own:
+ * {@link createSuspender} only leaves `pending` inside a `.then` callback, so
+ * the first read would still suspend for one microtask. Awaiting the returned
+ * promise resolves that race, because the callback registered by
+ * `createSuspender` runs before this one.
+ *
+ * @param key - Cache key, identical to the one the later read uses.
+ * @param loader - Invoked only when the key is not cached yet, so preloading a
+ *                 dictionary twice never issues a second request.
+ * @returns A promise that settles — never rejects — once the entry is readable.
+ */
+declare const preloadDynamic: <T>(key: string, loader: () => Promise<T>) => Promise<void>;
 //#endregion
-export { useLoadDynamic };
+export { preloadDynamic, useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";cA2Ba,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";cAqCa,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;cA2BxD,iBAAkB,GAAC,aACnB,cACG,QAAQ,OACrB"}

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

@@ -1,12 +1,13 @@
+import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
 declare const useLocaleBase: () => {
-  locale: import("@intlayer/types").LocalesValues;
+  locale: LocalesValues;
   defaultLocale: any;
   availableLocales: any;
-  setLocale: (newLocale: import("@intlayer/types").LocalesValues) => void;
+  setLocale: (newLocale: LocalesValues) => void;
 };
 //#endregion
 export { useLocaleBase };

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;cAWa"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;cAWa;UAAA;;;yBAAA"}

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

@@ -1,3 +1,4 @@
+import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocaleStorage.d.ts
 /**
@@ -6,13 +7,13 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: import("@intlayer/types").Locale;
+declare const localeInStorage: Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: import("@intlayer/types").Locale;
+declare const localeCookie: Locale;
 /**
  * Set the locale cookie
  */
@@ -27,7 +28,7 @@ declare const setLocaleCookie: typeof setLocaleInStorage;
  * Hook that provides the locale cookie and a function to set it
  */
 declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => import("@intlayer/types").Locale;
+  getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;cAea,2CAAe;;;;;;cAMf,wCAAY;;;;cAKZ,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;;sBAAhB;;;;;;;;;cAiBA,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;;cAea,iBAAA;;;;;;cAMA,cAAA;;;;cAKA,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;mBAAhB;sBAAA;;;;;;;;;cAiBA,wBAAe"}

package/dist/types/intlayer/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+import "@intlayer/core/interpreter";
+import { LocalesValues as LocalesValues$1 } from "@intlayer/types/module_augmentation";
+import "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+import { Locale } from "@intlayer/types/allLocales";
+import "@intlayer/types/locales";
+import "@intlayer/config/built";
+import "@intlayer/core/file";
+import "@intlayer/core/formatters";
+import "@intlayer/core/localization";
+import "@intlayer/core/markdown";
+import "@intlayer/core/transpiler";
+import "@intlayer/core/utils";
+export type { Locale, LocalesValues$1 as LocalesValues };

package/dist/types/server/useI18n.d.ts

@@ -1,7 +1,7 @@
 import { DeepTransformContent } from "../plugins.js";
 import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 import { GetSubPath } from "@intlayer/types/dictionary";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 //#region src/server/useI18n.d.ts
 /**
  * Hook that provides a translation function `t()` for accessing nested content by key.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intlayer",
-  "version": "9.3.2",
+  "version": "9.3.3",
   "private": false,
   "description": "Easily internationalize i18n your React applications with type-safe multilingual content management.",
   "keywords": [
@@ -133,11 +133,11 @@
   },
   "dependencies": {
     "@intlayer/api": "9.3.2",
-    "@intlayer/config": "9.3.2",
-    "@intlayer/core": "9.3.2",
-    "@intlayer/dictionaries-entry": "9.3.2",
-    "@intlayer/editor": "9.3.2",
-    "@intlayer/types": "9.3.2"
+    "@intlayer/config": "9.3.3",
+    "@intlayer/core": "9.3.3",
+    "@intlayer/dictionaries-entry": "9.3.3",
+    "@intlayer/editor": "9.3.3",
+    "@intlayer/types": "9.3.3"
   },
   "devDependencies": {
     "@craco/types": "7.1.0",
@@ -151,14 +151,14 @@
     "rimraf": "6.1.3",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "peerDependencies": {
     "react": ">=16.0.0",
     "react-dom": ">=16.0.0"
   },
   "optionalDependencies": {
-    "@intlayer/analytics": "9.3.2"
+    "@intlayer/analytics": "9.3.3"
   },
   "engines": {
     "node": ">=14.18"