preact-intlayer 8.5.2 → 8.6.1

package/dist/cjs/client/IntlayerProvider.cjs

@@ -20,7 +20,7 @@ const IntlayerClientContext = (0, preact.createContext)({
 /**
 * Hook that provides the current locale
 */
-const useIntlayerContext = () => (0, preact_hooks.useContext)(IntlayerClientContext);
+const useIntlayerContext = () => (0, preact_hooks.useContext)(IntlayerClientContext) ?? {};
 /**
 * Provider that store the current locale on the client side
 */

package/dist/cjs/client/IntlayerProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerProvider.cjs","names":["localeInStorage","configuration","EditorProvider"],"sources":["../../../src/client/IntlayerProvider.tsx"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { localeResolver } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport {\n  type ComponentChild,\n  createContext,\n  type FunctionComponent,\n} from 'preact';\nimport { useContext, useEffect, useState } from 'preact/hooks';\nimport { EditorProvider } from '../editor/EditorProvider';\nimport { localeInStorage, setLocaleInStorage } from './useLocaleStorage';\n\ntype IntlayerValue = {\n  locale: LocalesValues;\n  setLocale: (newLocale: LocalesValues) => void;\n  isCookieEnabled?: boolean;\n};\n\n/**\n * Context that store the current locale on the client side\n */\nexport const IntlayerClientContext = createContext<IntlayerValue>({\n  locale: localeInStorage ?? configuration?.internationalization?.defaultLocale,\n  setLocale: () => null,\n});\n\n/**\n * Hook that provides the current locale\n */\nexport const useIntlayerContext = () => useContext(IntlayerClientContext);\n\nexport type IntlayerProviderProps = {\n  children?: ComponentChild;\n  locale?: LocalesValues;\n  defaultLocale?: LocalesValues;\n  setLocale?: (locale: LocalesValues) => void;\n  isCookieEnabled?: boolean;\n};\n\n/**\n * Provider that store the current locale on the client side\n */\nexport const IntlayerProviderContent: FunctionComponent<\n  IntlayerProviderProps\n> = ({\n  locale: localeProp,\n  defaultLocale: defaultLocaleProp,\n  children,\n  setLocale: setLocaleProp,\n  isCookieEnabled,\n}) => {\n  const { internationalization } = configuration ?? {};\n  const { defaultLocale: defaultLocaleConfig, locales: availableLocales } =\n    internationalization ?? {};\n\n  const defaultLocale =\n    localeProp ?? localeInStorage ?? defaultLocaleProp ?? defaultLocaleConfig;\n\n  const [currentLocale, setCurrentLocale] = useState<LocalesValues>(\n    defaultLocale as LocalesValues\n  );\n\n  useEffect(() => {\n    if (localeProp && localeProp !== currentLocale) {\n      setCurrentLocale(localeProp);\n    }\n  }, [localeProp, currentLocale, setCurrentLocale]);\n\n  const setLocaleBase = (newLocale: LocalesValues) => {\n    if (currentLocale.toString() === newLocale.toString()) return;\n\n    if (!availableLocales?.map(String).includes(newLocale)) {\n      console.error(`Locale ${newLocale} is not available`);\n      return;\n    }\n\n    setCurrentLocale(newLocale); // Update state\n    setLocaleInStorage(newLocale, isCookieEnabled ?? true); // Optionally set cookie for persistence\n  };\n\n  const setLocale = setLocaleProp ?? setLocaleBase;\n\n  const resolvedLocale = localeResolver(localeProp ?? currentLocale);\n\n  return (\n    <IntlayerClientContext.Provider\n      value={{\n        locale: resolvedLocale,\n        setLocale,\n        isCookieEnabled,\n      }}\n    >\n      {children}\n    </IntlayerClientContext.Provider>\n  );\n};\n\n/**\n * Main provider for Intlayer in Preact applications.\n *\n * It provides the Intlayer context to your application, allowing the use\n * of hooks like `useIntlayer` and `useLocale`.\n *\n * @param props - The provider props.\n * @returns The provider component.\n *\n * @example\n * ```tsx\n * import { IntlayerProvider } from 'preact-intlayer';\n *\n * const App = () => (\n *   <IntlayerProvider>\n *     <MyComponent />\n *   </IntlayerProvider>\n * );\n * ```\n */\nexport const IntlayerProvider: FunctionComponent<IntlayerProviderProps> = ({\n  children,\n  ...props\n}) => (\n  <IntlayerProviderContent {...props}>\n    <EditorProvider />\n    {children}\n  </IntlayerProviderContent>\n);\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,MAAa,kDAAqD;CAChE,QAAQA,mDAAmBC,gCAAe,sBAAsB;CAChE,iBAAiB;CAClB,CAAC;;;;AAKF,MAAa,wDAAsC,sBAAsB;;;;AAazE,MAAa,2BAER,EACH,QAAQ,YACR,eAAe,mBACf,UACA,WAAW,eACX,sBACI;CACJ,MAAM,EAAE,yBAAyBA,kCAAiB,EAAE;CACpD,MAAM,EAAE,eAAe,qBAAqB,SAAS,qBACnD,wBAAwB,EAAE;CAK5B,MAAM,CAAC,eAAe,+CAFpB,cAAcD,mDAAmB,qBAAqB,oBAIvD;AAED,mCAAgB;AACd,MAAI,cAAc,eAAe,cAC/B,kBAAiB,WAAW;IAE7B;EAAC;EAAY;EAAe;EAAiB,CAAC;CAEjD,MAAM,iBAAiB,cAA6B;AAClD,MAAI,cAAc,UAAU,KAAK,UAAU,UAAU,CAAE;AAEvD,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,UAAU,EAAE;AACtD,WAAQ,MAAM,UAAU,UAAU,mBAAmB;AACrD;;AAGF,mBAAiB,UAAU;AAC3B,qDAAmB,WAAW,mBAAmB,KAAK;;CAGxD,MAAM,YAAY,iBAAiB;CAEnC,MAAM,iEAAgC,cAAc,cAAc;AAElE,QACE,4CAAC,sBAAsB,UAAvB;EACE,OAAO;GACL,QAAQ;GACR;GACA;GACD;EAEA;EAC8B;;;;;;;;;;;;;;;;;;;;;;AAwBrC,MAAa,oBAA8D,EACzE,UACA,GAAG,YAEH,6CAAC,yBAAD;CAAyB,GAAI;WAA7B,CACE,4CAACE,8CAAD,EAAkB,GACjB,SACuB"}
+{"version":3,"file":"IntlayerProvider.cjs","names":["localeInStorage","configuration","EditorProvider"],"sources":["../../../src/client/IntlayerProvider.tsx"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { localeResolver } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport {\n  type ComponentChild,\n  createContext,\n  type FunctionComponent,\n} from 'preact';\nimport { useContext, useEffect, useState } from 'preact/hooks';\nimport { EditorProvider } from '../editor/EditorProvider';\nimport { localeInStorage, setLocaleInStorage } from './useLocaleStorage';\n\ntype IntlayerValue = {\n  locale: LocalesValues;\n  setLocale: (newLocale: LocalesValues) => void;\n  isCookieEnabled?: boolean;\n};\n\n/**\n * Context that store the current locale on the client side\n */\nexport const IntlayerClientContext = createContext<IntlayerValue>({\n  locale: localeInStorage ?? configuration?.internationalization?.defaultLocale,\n  setLocale: () => null,\n});\n\n/**\n * Hook that provides the current locale\n */\nexport const useIntlayerContext = () => useContext(IntlayerClientContext) ?? {};\n\nexport type IntlayerProviderProps = {\n  children?: ComponentChild;\n  locale?: LocalesValues;\n  defaultLocale?: LocalesValues;\n  setLocale?: (locale: LocalesValues) => void;\n  isCookieEnabled?: boolean;\n};\n\n/**\n * Provider that store the current locale on the client side\n */\nexport const IntlayerProviderContent: FunctionComponent<\n  IntlayerProviderProps\n> = ({\n  locale: localeProp,\n  defaultLocale: defaultLocaleProp,\n  children,\n  setLocale: setLocaleProp,\n  isCookieEnabled,\n}) => {\n  const { internationalization } = configuration ?? {};\n  const { defaultLocale: defaultLocaleConfig, locales: availableLocales } =\n    internationalization ?? {};\n\n  const defaultLocale =\n    localeProp ?? localeInStorage ?? defaultLocaleProp ?? defaultLocaleConfig;\n\n  const [currentLocale, setCurrentLocale] = useState<LocalesValues>(\n    defaultLocale as LocalesValues\n  );\n\n  useEffect(() => {\n    if (localeProp && localeProp !== currentLocale) {\n      setCurrentLocale(localeProp);\n    }\n  }, [localeProp, currentLocale, setCurrentLocale]);\n\n  const setLocaleBase = (newLocale: LocalesValues) => {\n    if (currentLocale.toString() === newLocale.toString()) return;\n\n    if (!availableLocales?.map(String).includes(newLocale)) {\n      console.error(`Locale ${newLocale} is not available`);\n      return;\n    }\n\n    setCurrentLocale(newLocale); // Update state\n    setLocaleInStorage(newLocale, isCookieEnabled ?? true); // Optionally set cookie for persistence\n  };\n\n  const setLocale = setLocaleProp ?? setLocaleBase;\n\n  const resolvedLocale = localeResolver(localeProp ?? currentLocale);\n\n  return (\n    <IntlayerClientContext.Provider\n      value={{\n        locale: resolvedLocale,\n        setLocale,\n        isCookieEnabled,\n      }}\n    >\n      {children}\n    </IntlayerClientContext.Provider>\n  );\n};\n\n/**\n * Main provider for Intlayer in Preact applications.\n *\n * It provides the Intlayer context to your application, allowing the use\n * of hooks like `useIntlayer` and `useLocale`.\n *\n * @param props - The provider props.\n * @returns The provider component.\n *\n * @example\n * ```tsx\n * import { IntlayerProvider } from 'preact-intlayer';\n *\n * const App = () => (\n *   <IntlayerProvider>\n *     <MyComponent />\n *   </IntlayerProvider>\n * );\n * ```\n */\nexport const IntlayerProvider: FunctionComponent<IntlayerProviderProps> = ({\n  children,\n  ...props\n}) => (\n  <IntlayerProviderContent {...props}>\n    <EditorProvider />\n    {children}\n  </IntlayerProviderContent>\n);\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,MAAa,kDAAqD;CAChE,QAAQA,mDAAmBC,gCAAe,sBAAsB;CAChE,iBAAiB;CAClB,CAAC;;;;AAKF,MAAa,wDAAsC,sBAAsB,IAAI,EAAE;;;;AAa/E,MAAa,2BAER,EACH,QAAQ,YACR,eAAe,mBACf,UACA,WAAW,eACX,sBACI;CACJ,MAAM,EAAE,yBAAyBA,kCAAiB,EAAE;CACpD,MAAM,EAAE,eAAe,qBAAqB,SAAS,qBACnD,wBAAwB,EAAE;CAK5B,MAAM,CAAC,eAAe,+CAFpB,cAAcD,mDAAmB,qBAAqB,oBAIvD;AAED,mCAAgB;AACd,MAAI,cAAc,eAAe,cAC/B,kBAAiB,WAAW;IAE7B;EAAC;EAAY;EAAe;EAAiB,CAAC;CAEjD,MAAM,iBAAiB,cAA6B;AAClD,MAAI,cAAc,UAAU,KAAK,UAAU,UAAU,CAAE;AAEvD,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,UAAU,EAAE;AACtD,WAAQ,MAAM,UAAU,UAAU,mBAAmB;AACrD;;AAGF,mBAAiB,UAAU;AAC3B,qDAAmB,WAAW,mBAAmB,KAAK;;CAGxD,MAAM,YAAY,iBAAiB;CAEnC,MAAM,iEAAgC,cAAc,cAAc;AAElE,QACE,4CAAC,sBAAsB,UAAvB;EACE,OAAO;GACL,QAAQ;GACR;GACA;GACD;EAEA;EAC8B;;;;;;;;;;;;;;;;;;;;;;AAwBrC,MAAa,oBAA8D,EACzE,UACA,GAAG,YAEH,6CAAC,yBAAD;CAAyB,GAAI;WAA7B,CACE,4CAACE,8CAAD,EAAkB,GACjB,SACuB"}

package/dist/cjs/client/t.cjs

@@ -11,7 +11,7 @@ let preact_hooks = require("preact/hooks");
 * If the locale is not provided, it will use the locale from the client context
 */
 const t = (multilangContent, locale) => {
-	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, _intlayer_core_interpreter.getTranslation)(multilangContent, locale ?? currentLocale);
 };
 

package/dist/cjs/client/t.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"t.cjs","names":["IntlayerClientContext"],"sources":["../../../src/client/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the client side, this function returns the translation of the provided multilang content.\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const t = <Content = string>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: Locale\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,KACX,kBACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;AAGnE,uDAA+B,kBAFV,UAAU,cAE+B"}
+{"version":3,"file":"t.cjs","names":["IntlayerClientContext"],"sources":["../../../src/client/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the client side, this function returns the translation of the provided multilang content.\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const t = <Content = string>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: Locale\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n  const localeTarget = locale ?? currentLocale;\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,KACX,kBACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;AAGzE,uDAA+B,kBAFV,UAAU,cAE+B"}

package/dist/cjs/client/useDictionary.cjs

@@ -11,7 +11,7 @@ let preact_hooks = require("preact/hooks");
 * If the locale is not provided, it will use the locale from the client context
 */
 const useDictionary = (dictionary, locale) => {
-	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useMemo)(() => {
 		return require_getDictionary.getDictionary(dictionary, locale ?? currentLocale);
 	}, [

package/dist/cjs/client/useDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.cjs","names":["IntlayerClientContext","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    return getDictionary<T, L>(dictionary, localeTarget as L);\n  }, [dictionary.key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;AAEnE,wCAAqB;AAGnB,SAAOC,oCAAoB,YAFN,UAAU,cAE0B;IACxD;EAAC,WAAW;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useDictionary.cjs","names":["IntlayerClientContext","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    return getDictionary<T, L>(dictionary, localeTarget as L);\n  }, [dictionary.key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;AAEzE,wCAAqB;AAGnB,SAAOC,oCAAoB,YAFN,UAAU,cAE0B;IACxD;EAAC,WAAW;EAAK;EAAe;EAAO,CAAC"}

package/dist/cjs/client/useDictionaryAsync.cjs

@@ -13,7 +13,7 @@ let preact_hooks = require("preact/hooks");
 * If the locale is not provided, it will use the locale from the client context
 */
 const useDictionaryAsync = async (dictionaryPromise, locale) => {
-	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const localeTarget = (0, preact_hooks.useMemo)(() => locale ?? currentLocale ?? _intlayer_config_built.default?.internationalization.defaultLocale, [currentLocale, locale]);
 	return require_client_useDictionary.useDictionary(await (0, preact_hooks.useMemo)(async () => await dictionaryPromise[localeTarget]?.(), [dictionaryPromise, localeTarget]), localeTarget);
 };

package/dist/cjs/client/useDictionaryAsync.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.cjs","names":["IntlayerClientContext","configuration","useDictionary"],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <T extends Dictionary>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: LocalesValues\n): Promise<T> => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n\n  const localeTarget = useMemo(\n    () =>\n      locale ??\n      currentLocale ??\n      configuration?.internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = await useMemo(\n    async () =>\n      (await dictionaryPromise[\n        localeTarget as keyof typeof dictionaryPromise\n      ]?.()) as T,\n    [dictionaryPromise, localeTarget]\n  );\n\n  return useDictionary(dictionary, localeTarget) as any;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,qBAAqB,OAChC,mBACA,WACe;CACf,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;CAEnE,MAAM,+CAEF,UACA,iBACAC,gCAAe,qBAAqB,eACtC,CAAC,eAAe,OAAO,CACxB;AAUD,QAAOC,2CARY,gCACjB,YACG,MAAM,kBACL,iBACG,EACP,CAAC,mBAAmB,aAAa,CAClC,EAEgC,aAAa"}
+{"version":3,"file":"useDictionaryAsync.cjs","names":["IntlayerClientContext","configuration","useDictionary"],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <T extends Dictionary>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: LocalesValues\n): Promise<T> => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  const localeTarget = useMemo(\n    () =>\n      locale ??\n      currentLocale ??\n      configuration?.internationalization.defaultLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = await useMemo(\n    async () =>\n      (await dictionaryPromise[\n        localeTarget as keyof typeof dictionaryPromise\n      ]?.()) as T,\n    [dictionaryPromise, localeTarget]\n  );\n\n  return useDictionary(dictionary, localeTarget) as any;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,qBAAqB,OAChC,mBACA,WACe;CACf,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CAEzE,MAAM,+CAEF,UACA,iBACAC,gCAAe,qBAAqB,eACtC,CAAC,eAAe,OAAO,CACxB;AAUD,QAAOC,2CARY,gCACjB,YACG,MAAM,kBACL,iBACG,EACP,CAAC,mBAAmB,aAAa,CAClC,EAEgC,aAAa"}

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -12,7 +12,7 @@ let preact_hooks = require("preact/hooks");
 * If the locale is not provided, it will use the locale from the client context
 */
 const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
-	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const localeTarget = (0, preact_hooks.useMemo)(() => locale ?? currentLocale, [currentLocale, locale]);
 	return require_client_useDictionary.useDictionary(require_client_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
 };

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["IntlayerClientContext","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;AAgBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;CACnE,MAAM,+CACE,UAAU,eAChB,CAAC,eAAe,OAAO,CACxB;AAOD,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAC7C,EAEgC,aAAa"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["IntlayerClientContext","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n  const localeTarget = useMemo(\n    () => locale ?? currentLocale,\n    [currentLocale, locale]\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;AAgBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CACzE,MAAM,+CACE,UAAU,eAChB,CAAC,eAAe,OAAO,CACxB;AAOD,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAC7C,EAEgC,aAAa"}

package/dist/cjs/client/useIntlayer.cjs

@@ -26,7 +26,7 @@ let preact_hooks = require("preact/hooks");
 * ```
 */
 const useIntlayer = (key, locale) => {
-	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: currentLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useMemo)(() => {
 		return require_getIntlayer.getIntlayer(key, locale ?? currentLocale);
 	}, [

package/dist/cjs/client/useIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.cjs","names":["IntlayerClientContext","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact hook that picks one dictionary by its key and returns its content.\n *\n * If the locale is not provided, it will use the locale from the client context.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    // @ts-ignore Type instantiation is excessively deep and possibly infinite\n    return getIntlayer<T, L>(key, localeTarget as L) as DeepTransformContent<\n      DictionaryRegistryContent<T>\n    >;\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,eACX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;AAEnE,wCAAqB;AAInB,SAAOC,gCAAkB,KAHJ,UAAU,cAGiB;IAG/C;EAAC;EAAK;EAAe;EAAO,CAAC"}
+{"version":3,"file":"useIntlayer.cjs","names":["IntlayerClientContext","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Preact hook that picks one dictionary by its key and returns its content.\n *\n * If the locale is not provided, it will use the locale from the client context.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The transformed dictionary content.\n *\n * @example\n * ```tsx\n * import { useIntlayer } from 'preact-intlayer';\n *\n * const MyComponent = () => {\n *   const content = useIntlayer('my-dictionary-key');\n *\n *   return <div>{content.myField.value}</div>;\n * };\n * ```\n */\nexport const useIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: L\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(() => {\n    const localeTarget = locale ?? currentLocale;\n\n    // @ts-ignore Type instantiation is excessively deep and possibly infinite\n    return getIntlayer<T, L>(key, localeTarget as L) as DeepTransformContent<\n      DictionaryRegistryContent<T>\n    >;\n  }, [key, currentLocale, locale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,eACX,KACA,WACG;CACH,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;AAEzE,wCAAqB;AAInB,SAAOC,gCAAkB,KAHJ,UAAU,cAGiB;IAG/C;EAAC;EAAK;EAAe;EAAO,CAAC"}

package/dist/cjs/client/useLocale.cjs

@@ -32,7 +32,7 @@ let preact_hooks = require("preact/hooks");
 */
 const useLocale = ({ isCookieEnabled, onLocaleChange } = {}) => {
 	const { defaultLocale, locales: availableLocales } = _intlayer_config_built.default?.internationalization ?? {};
-	const { locale, setLocale: setLocaleState, isCookieEnabled: isCookieEnabledContext } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale, setLocale: setLocaleState, isCookieEnabled: isCookieEnabledContext } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const setLocale = (locale) => {
 		if (!availableLocales?.map(String).includes(locale)) {
 			console.error(`Locale ${locale} is not available`);

package/dist/cjs/client/useLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.cjs","names":["configuration","IntlayerClientContext"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype useLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: useLocaleProps = {}) => {\n  const { defaultLocale, locales: availableLocales } =\n    configuration?.internationalization ?? {};\n\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext);\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,aAAa,EACxB,iBACA,mBACkB,EAAE,KAAK;CACzB,MAAM,EAAE,eAAe,SAAS,qBAC9BA,gCAAe,wBAAwB,EAAE;CAE3C,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,wDACJC,sDAAsB;CAErC,MAAM,aAAa,WAA0B;AAC3C,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,OAAO,EAAE;AACnD,WAAQ,MAAM,UAAU,OAAO,mBAAmB;AAClD;;AAGF,iBAAe,OAAO;AAEtB,qDACE,QACA,mBAAmB,0BAA0B,KAC9C;AAED,mBAAiB,OAAO;;AAG1B,QAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"useLocale.cjs","names":["configuration","IntlayerClientContext"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype useLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: useLocaleProps = {}) => {\n  const { defaultLocale, locales: availableLocales } =\n    configuration?.internationalization ?? {};\n\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext) ?? {};\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,aAAa,EACxB,iBACA,mBACkB,EAAE,KAAK;CACzB,MAAM,EAAE,eAAe,SAAS,qBAC9BA,gCAAe,wBAAwB,EAAE;CAE3C,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,wDACJC,sDAAsB,IAAI,EAAE;CAE3C,MAAM,aAAa,WAA0B;AAC3C,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,OAAO,EAAE;AACnD,WAAQ,MAAM,UAAU,OAAO,mBAAmB;AAClD;;AAGF,iBAAe,OAAO;AAEtB,qDACE,QACA,mBAAmB,0BAA0B,KAC9C;AAED,mBAAiB,OAAO;;AAG1B,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/cjs/client/useLocaleBase.cjs

@@ -11,7 +11,7 @@ const { defaultLocale, locales: availableLocales } = _intlayer_config_built.defa
 * On the client side, hook to get the current locale and all related fields
 */
 const useLocaleBase = () => {
-	const { locale, setLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale, setLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return {
 		locale,
 		defaultLocale,

package/dist/cjs/client/useLocaleBase.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.cjs","names":["configuration","IntlayerClientContext"],"sources":["../../../src/client/useLocaleBase.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\nconst { defaultLocale, locales: availableLocales } =\n  configuration.internationalization;\n\n/**\n * On the client side, hook to get the current locale and all related fields\n */\nexport const useLocaleBase = () => {\n  const { locale, setLocale } = useContext(IntlayerClientContext);\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;AAIA,MAAM,EAAE,eAAe,SAAS,qBAC9BA,+BAAc;;;;AAKhB,MAAa,sBAAsB;CACjC,MAAM,EAAE,QAAQ,2CAAyBC,sDAAsB;AAE/D,QAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"useLocaleBase.cjs","names":["configuration","IntlayerClientContext"],"sources":["../../../src/client/useLocaleBase.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\nconst { defaultLocale, locales: availableLocales } =\n  configuration.internationalization;\n\n/**\n * On the client side, hook to get the current locale and all related fields\n */\nexport const useLocaleBase = () => {\n  const { locale, setLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;AAIA,MAAM,EAAE,eAAe,SAAS,qBAC9BA,+BAAc;;;;AAKhB,MAAa,sBAAsB;CACjC,MAAM,EAAE,QAAQ,2CAAyBC,sDAAsB,IAAI,EAAE;AAErE,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/cjs/client/useLocaleStorage.cjs

@@ -8,7 +8,7 @@ let _intlayer_core_utils = require("@intlayer/core/utils");
 /**
 * Get the locale cookie
 */
-const localeInStorage = (0, _intlayer_core_utils.getLocaleFromStorage)(_intlayer_core_localization.localeStorageOptions);
+const localeInStorage = (0, _intlayer_core_utils.getLocaleFromStorageClient)(_intlayer_core_localization.localeStorageOptions);
 /**
 * @deprecated Use localeInStorage instead
 *
@@ -18,7 +18,7 @@ const localeCookie = localeInStorage;
 /**
 * Set the locale cookie
 */
-const setLocaleInStorage = (locale, isCookieEnabled) => (0, _intlayer_core_utils.setLocaleInStorage)(locale, {
+const setLocaleInStorage = (locale, isCookieEnabled) => (0, _intlayer_core_utils.setLocaleInStorageClient)(locale, {
 	..._intlayer_core_localization.localeStorageOptions,
 	isCookieEnabled
 });
@@ -31,7 +31,7 @@ const setLocaleCookie = setLocaleInStorage;
 /**
 * Hook that provides the locale storage and a function to set it
 */
-const useLocaleStorage = (isCookieEnabled) => (0, preact_hooks.useMemo)(() => (0, _intlayer_core_utils.LocaleStorage)({
+const useLocaleStorage = (isCookieEnabled) => (0, preact_hooks.useMemo)(() => (0, _intlayer_core_utils.LocaleStorageClient)({
 	..._intlayer_core_localization.localeStorageOptions,
 	isCookieEnabled
 }), [isCookieEnabled]);

package/dist/cjs/client/useLocaleStorage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.cjs","names":["localeStorageOptions"],"sources":["../../../src/client/useLocaleStorage.ts"],"sourcesContent":["import { localeStorageOptions } from '@intlayer/core/localization';\nimport {\n  getLocaleFromStorage,\n  LocaleStorage,\n  setLocaleInStorage as setLocaleInStorageCore,\n} from '@intlayer/core/utils';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useMemo } from 'preact/hooks';\n\n/**\n * Get the locale cookie\n */\nexport const localeInStorage = getLocaleFromStorage(localeStorageOptions);\n/**\n * @deprecated Use localeInStorage instead\n *\n * Get the locale cookie\n */\nexport const localeCookie = localeInStorage;\n\n/**\n * Set the locale cookie\n */\nexport const setLocaleInStorage = (\n  locale: LocalesValues,\n  isCookieEnabled: boolean\n) =>\n  setLocaleInStorageCore(locale, {\n    ...localeStorageOptions,\n    isCookieEnabled,\n  });\n\n/**\n * @deprecated Use setLocaleInStorage instead\n *\n * Set the locale cookie\n */\nexport const setLocaleCookie = setLocaleInStorage;\n\n/**\n * Hook that provides the locale storage and a function to set it\n */\nexport const useLocaleStorage = (isCookieEnabled?: boolean) =>\n  useMemo(\n    () =>\n      LocaleStorage({\n        ...localeStorageOptions,\n        isCookieEnabled,\n      }),\n    [isCookieEnabled]\n  );\n\n/**\n * @deprecated Use useLocaleStorage instead\n *\n * For GDPR compliance, use useLocaleStorage instead\n *\n * Hook that provides the locale cookie and a function to set it\n */\nexport const useLocaleCookie = (isCookieEnabled?: boolean) => {\n  const storage = useLocaleStorage(isCookieEnabled);\n  return {\n    localeCookie: storage.getLocale(),\n    setLocaleCookie: storage.setLocale,\n  };\n};\n"],"mappings":";;;;;;;;;;AAYA,MAAa,iEAAuCA,iDAAqB;;;;;;AAMzE,MAAa,eAAe;;;;AAK5B,MAAa,sBACX,QACA,iEAEuB,QAAQ;CAC7B,GAAGA;CACH;CACD,CAAC;;;;;;AAOJ,MAAa,kBAAkB;;;;AAK/B,MAAa,oBAAoB,4FAGb;CACZ,GAAGA;CACH;CACD,CAAC,EACJ,CAAC,gBAAgB,CAClB;;;;;;;;AASH,MAAa,mBAAmB,oBAA8B;CAC5D,MAAM,UAAU,iBAAiB,gBAAgB;AACjD,QAAO;EACL,cAAc,QAAQ,WAAW;EACjC,iBAAiB,QAAQ;EAC1B"}
+{"version":3,"file":"useLocaleStorage.cjs","names":["localeStorageOptions"],"sources":["../../../src/client/useLocaleStorage.ts"],"sourcesContent":["import { localeStorageOptions } from '@intlayer/core/localization';\nimport {\n  getLocaleFromStorageClient,\n  LocaleStorageClient,\n  setLocaleInStorageClient as setLocaleInStorageCore,\n} from '@intlayer/core/utils';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useMemo } from 'preact/hooks';\n\n/**\n * Get the locale cookie\n */\nexport const localeInStorage = getLocaleFromStorageClient(localeStorageOptions);\n/**\n * @deprecated Use localeInStorage instead\n *\n * Get the locale cookie\n */\nexport const localeCookie = localeInStorage;\n\n/**\n * Set the locale cookie\n */\nexport const setLocaleInStorage = (\n  locale: LocalesValues,\n  isCookieEnabled: boolean\n) =>\n  setLocaleInStorageCore(locale, {\n    ...localeStorageOptions,\n    isCookieEnabled,\n  });\n\n/**\n * @deprecated Use setLocaleInStorage instead\n *\n * Set the locale cookie\n */\nexport const setLocaleCookie = setLocaleInStorage;\n\n/**\n * Hook that provides the locale storage and a function to set it\n */\nexport const useLocaleStorage = (isCookieEnabled?: boolean) =>\n  useMemo(\n    () =>\n      LocaleStorageClient({\n        ...localeStorageOptions,\n        isCookieEnabled,\n      }),\n    [isCookieEnabled]\n  );\n\n/**\n * @deprecated Use useLocaleStorage instead\n *\n * For GDPR compliance, use useLocaleStorage instead\n *\n * Hook that provides the locale cookie and a function to set it\n */\nexport const useLocaleCookie = (isCookieEnabled?: boolean) => {\n  const storage = useLocaleStorage(isCookieEnabled);\n  return {\n    localeCookie: storage.getLocale(),\n    setLocaleCookie: storage.setLocale,\n  };\n};\n"],"mappings":";;;;;;;;;;AAYA,MAAa,uEAA6CA,iDAAqB;;;;;;AAM/E,MAAa,eAAe;;;;AAK5B,MAAa,sBACX,QACA,uEAEuB,QAAQ;CAC7B,GAAGA;CACH;CACD,CAAC;;;;;;AAOJ,MAAa,kBAAkB;;;;AAK/B,MAAa,oBAAoB,kGAGP;CAClB,GAAGA;CACH;CACD,CAAC,EACJ,CAAC,gBAAgB,CAClB;;;;;;;;AASH,MAAa,mBAAmB,oBAA8B;CAC5D,MAAM,UAAU,iBAAiB,gBAAgB;AACjD,QAAO;EACL,cAAc,QAAQ,WAAW;EACjC,iBAAiB,QAAQ;EAC1B"}

package/dist/cjs/client/useTraduction.cjs

@@ -27,7 +27,7 @@ let preact_hooks = require("preact/hooks");
 * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
 */
 const useTranslation = (languageContent) => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useMemo)(() => (0, _intlayer_core_interpreter.getTranslation)(languageContent, locale), [languageContent, locale]);
 };
 

package/dist/cjs/client/useTraduction.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useTraduction.cjs","names":["IntlayerClientContext"],"sources":["../../../src/client/useTraduction.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the client side, Hook that picking one dictionary by its id and return the content.\n *\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```tsx\n * const content = useTranslation<string>({\n *  en: 'Hello',\n *  fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const useTranslation = <Content = string>(\n  languageContent: StrictModeLocaleMap<Content>\n): Content => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useMemo(\n    () => getTranslation(languageContent, locale),\n    [languageContent, locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,kBACX,oBACY;CACZ,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uFACuB,iBAAiB,OAAO,EAC7C,CAAC,iBAAiB,OAAO,CAC1B"}
+{"version":3,"file":"useTraduction.cjs","names":["IntlayerClientContext"],"sources":["../../../src/client/useTraduction.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * On the client side, Hook that picking one dictionary by its id and return the content.\n *\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```tsx\n * const content = useTranslation<string>({\n *  en: 'Hello',\n *  fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const useTranslation = <Content = string>(\n  languageContent: StrictModeLocaleMap<Content>\n): Content => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(\n    () => getTranslation(languageContent, locale),\n    [languageContent, locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,kBACX,oBACY;CACZ,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uFACuB,iBAAiB,OAAO,EAC7C,CAAC,iBAAiB,OAAO,CAC1B"}

package/dist/cjs/editor/useEditor.cjs

@@ -11,7 +11,7 @@ let preact_hooks = require("preact/hooks");
 * the editor always knows which locale the app is displaying.
 */
 const useEditor = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const managerRef = (0, preact_hooks.useRef)(null);
 	(0, preact_hooks.useEffect)(() => {
 		if (process.env.INTLAYER_EDITOR_ENABLED === "false" || !_intlayer_editor_isEnabled.isEnabled) return;

package/dist/cjs/editor/useEditor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.cjs","names":["IntlayerClientContext","isEnabled"],"sources":["../../../src/editor/useEditor.tsx"],"sourcesContent":["import type { EditorStateManager } from '@intlayer/editor';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useContext, useEffect, useRef } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Initialises the Intlayer editor client singleton when the editor is enabled.\n * Syncs the current locale from the Intlayer context into the editor manager so\n * the editor always knows which locale the app is displaying.\n */\nexport const useEditor = () => {\n  const { locale } = useContext(IntlayerClientContext);\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  useEffect(() => {\n    if (process.env.INTLAYER_EDITOR_ENABLED === 'false' || !isEnabled) return;\n\n    import('@intlayer/editor').then(({ initEditorClient }) => {\n      const manager = initEditorClient();\n      managerRef.current = manager;\n\n      if (locale) manager.currentLocale.set(locale as Locale);\n    });\n\n    return () => {\n      managerRef.current = null;\n      import('@intlayer/editor').then(({ stopEditorClient }) => {\n        stopEditorClient();\n      });\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!locale || !managerRef.current) return;\n\n    managerRef.current.currentLocale.set(locale as Locale);\n  }, [locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,wCAAsBA,sDAAsB;CACpD,MAAM,sCAA+C,KAAK;AAE1D,mCAAgB;AACd,MAAI,QAAQ,IAAI,4BAA4B,WAAW,CAACC,qCAAW;AAEnE,SAAO,oBAAoB,MAAM,EAAE,uBAAuB;GACxD,MAAM,UAAU,kBAAkB;AAClC,cAAW,UAAU;AAErB,OAAI,OAAQ,SAAQ,cAAc,IAAI,OAAiB;IACvD;AAEF,eAAa;AACX,cAAW,UAAU;AACrB,UAAO,oBAAoB,MAAM,EAAE,uBAAuB;AACxD,sBAAkB;KAClB;;IAEH,EAAE,CAAC;AAEN,mCAAgB;AACd,MAAI,CAAC,UAAU,CAAC,WAAW,QAAS;AAEpC,aAAW,QAAQ,cAAc,IAAI,OAAiB;IACrD,CAAC,OAAO,CAAC"}
+{"version":3,"file":"useEditor.cjs","names":["IntlayerClientContext","isEnabled"],"sources":["../../../src/editor/useEditor.tsx"],"sourcesContent":["import type { EditorStateManager } from '@intlayer/editor';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { useContext, useEffect, useRef } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Initialises the Intlayer editor client singleton when the editor is enabled.\n * Syncs the current locale from the Intlayer context into the editor manager so\n * the editor always knows which locale the app is displaying.\n */\nexport const useEditor = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n  const managerRef = useRef<EditorStateManager | null>(null);\n\n  useEffect(() => {\n    if (process.env.INTLAYER_EDITOR_ENABLED === 'false' || !isEnabled) return;\n\n    import('@intlayer/editor').then(({ initEditorClient }) => {\n      const manager = initEditorClient();\n      managerRef.current = manager;\n\n      if (locale) manager.currentLocale.set(locale as Locale);\n    });\n\n    return () => {\n      managerRef.current = null;\n      import('@intlayer/editor').then(({ stopEditorClient }) => {\n        stopEditorClient();\n      });\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!locale || !managerRef.current) return;\n\n    managerRef.current.currentLocale.set(locale as Locale);\n  }, [locale]);\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;CAC1D,MAAM,sCAA+C,KAAK;AAE1D,mCAAgB;AACd,MAAI,QAAQ,IAAI,4BAA4B,WAAW,CAACC,qCAAW;AAEnE,SAAO,oBAAoB,MAAM,EAAE,uBAAuB;GACxD,MAAM,UAAU,kBAAkB;AAClC,cAAW,UAAU;AAErB,OAAI,OAAQ,SAAQ,cAAc,IAAI,OAAiB;IACvD;AAEF,eAAa;AACX,cAAW,UAAU;AACrB,UAAO,oBAAoB,MAAM,EAAE,uBAAuB;AACxD,sBAAkB;KAClB;;IAEH,EAAE,CAAC;AAEN,mCAAgB;AACd,MAAI,CAAC,UAAU,CAAC,WAAW,QAAS;AAEpC,aAAW,QAAQ,cAAc,IAAI,OAAiB;IACrD,CAAC,OAAO,CAAC"}

package/dist/cjs/format/useCompact.cjs

@@ -16,7 +16,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * ```
 */
 const useCompact = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.compact)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useCompact.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useCompact.ts"],"sourcesContent":["import { compact } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a compact number formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatCompact = useCompact();\n * formatCompact(1500); // \"1.5K\"\n * ```\n */\nexport const useCompact = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof compact>) =>\n      compact(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAcA,MAAa,mBAAmB;CAC9B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,gDACM,KAAK,IAAI;EACf,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useCompact.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useCompact.ts"],"sourcesContent":["import { compact } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a compact number formatter\n * bound to the current application locale.\n *\n * @example\n * ```tsx\n * const formatCompact = useCompact();\n * formatCompact(1500); // \"1.5K\"\n * ```\n */\nexport const useCompact = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof compact>) =>\n      compact(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAcA,MAAa,mBAAmB;CAC9B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,gDACM,KAAK,IAAI;EACf,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/useCurrency.cjs

@@ -30,7 +30,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * ```
 */
 const useCurrency = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.currency)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useCurrency.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useCurrency.ts"],"sourcesContent":["import { currency } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a currency formatter\n * bound to the current application locale.\n *\n * @returns {(value: string | number, options?: CurrencyProps) => string}\n * A function to format numbers into localized currency strings.\n *\n * @example\n * ```tsx\n * const formatCurrency = useCurrency();\n *\n * formatCurrency(1500, { currency: \"USD\" });\n * // \"$1,500.00\"\n *\n * formatCurrency(1500, { currency: \"EUR\", locale: \"de-DE\" });\n * // \"1.500,00 €\"\n *\n * formatCurrency(9876543.21, {\n *   currency: \"JPY\",\n *   fractionDigits: 0,\n * });\n * // \"¥9,876,543\"\n * ```\n */\nexport const useCurrency = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof currency>) =>\n      currency(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,oBAAoB;CAC/B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,iDACO,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useCurrency.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useCurrency.ts"],"sourcesContent":["import { currency } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a currency formatter\n * bound to the current application locale.\n *\n * @returns {(value: string | number, options?: CurrencyProps) => string}\n * A function to format numbers into localized currency strings.\n *\n * @example\n * ```tsx\n * const formatCurrency = useCurrency();\n *\n * formatCurrency(1500, { currency: \"USD\" });\n * // \"$1,500.00\"\n *\n * formatCurrency(1500, { currency: \"EUR\", locale: \"de-DE\" });\n * // \"1.500,00 €\"\n *\n * formatCurrency(9876543.21, {\n *   currency: \"JPY\",\n *   fractionDigits: 0,\n * });\n * // \"¥9,876,543\"\n * ```\n */\nexport const useCurrency = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof currency>) =>\n      currency(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,oBAAoB;CAC/B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,iDACO,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/useDate.cjs

@@ -32,7 +32,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * @see createDate
 */
 const useDate = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (...args) => (0, _intlayer_core_formatters.date)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useDate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a localized date/time formatter\n * bound to the current application locale.\n *\n * @returns {(date: Date | string | number, options?: DateProps) => string}\n * A function to format dates or timestamps into localized date/time strings.\n *\n * @example\n * ```tsx\n * const formatDate = useDate();\n *\n * formatDate(new Date(\"2025-01-01\"));\n * // \"Jan 1, 2025\"\n *\n * formatDate(\"2025-01-01T15:30:00Z\", {\n *   dateStyle: \"full\",\n *   timeStyle: \"short\",\n * });\n * // \"Wednesday, January 1, 2025 at 3:30 PM\"\n *\n * formatDate(1735689600000, { locale: \"fr-FR\", dateStyle: \"long\" });\n * // \"1 janvier 2025\"\n * ```\n *\n * @see createDate\n */\nexport const useDate = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,SAAQ,GAAG,6CACJ,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}
+{"version":3,"file":"useDate.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a localized date/time formatter\n * bound to the current application locale.\n *\n * @returns {(date: Date | string | number, options?: DateProps) => string}\n * A function to format dates or timestamps into localized date/time strings.\n *\n * @example\n * ```tsx\n * const formatDate = useDate();\n *\n * formatDate(new Date(\"2025-01-01\"));\n * // \"Jan 1, 2025\"\n *\n * formatDate(\"2025-01-01T15:30:00Z\", {\n *   dateStyle: \"full\",\n *   timeStyle: \"short\",\n * });\n * // \"Wednesday, January 1, 2025 at 3:30 PM\"\n *\n * formatDate(1735689600000, { locale: \"fr-FR\", dateStyle: \"long\" });\n * // \"1 janvier 2025\"\n * ```\n *\n * @see createDate\n */\nexport const useDate = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,SAAQ,GAAG,6CACJ,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

package/dist/cjs/format/useIntl.cjs

@@ -24,7 +24,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * ```
 */
 const useIntl = (locale) => {
-	const { locale: contextLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale: contextLocale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const currentLocale = locale ?? contextLocale;
 	return (0, preact_hooks.useMemo)(() => (0, _intlayer_core_formatters.bindIntl)(currentLocale), [currentLocale]);
 };

package/dist/cjs/format/useIntl.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useIntl.ts"],"sourcesContent":["import { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Preact client hook that provides a locale-bound `Intl` object.\n *\n * It acts exactly like the native `Intl` object, but acts as a proxy to:\n * 1. Inject the current locale automatically if none is provided.\n * 2. Use the performance-optimized `CachedIntl` under the hood.\n *\n * @example\n * ```tsx\n * const intl = useIntl(); // uses context locale\n *\n * // Standard API, but no need to pass locale as the first argument\n * const formatted = new intl.NumberFormat({\n *   style: 'currency',\n *   currency: 'USD'\n * }).format(123.45);\n * ```\n */\nexport const useIntl = (locale?: LocalesValues) => {\n  const { locale: contextLocale } = useContext(IntlayerClientContext);\n  const currentLocale = locale ?? contextLocale;\n\n  return useMemo<WrappedIntl>(() => bindIntl(currentLocale), [currentLocale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,WAAW,WAA2B;CACjD,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB;CACnE,MAAM,gBAAgB,UAAU;AAEhC,gFAA2C,cAAc,EAAE,CAAC,cAAc,CAAC"}
+{"version":3,"file":"useIntl.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useIntl.ts"],"sourcesContent":["import { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Preact client hook that provides a locale-bound `Intl` object.\n *\n * It acts exactly like the native `Intl` object, but acts as a proxy to:\n * 1. Inject the current locale automatically if none is provided.\n * 2. Use the performance-optimized `CachedIntl` under the hood.\n *\n * @example\n * ```tsx\n * const intl = useIntl(); // uses context locale\n *\n * // Standard API, but no need to pass locale as the first argument\n * const formatted = new intl.NumberFormat({\n *   style: 'currency',\n *   currency: 'USD'\n * }).format(123.45);\n * ```\n */\nexport const useIntl = (locale?: LocalesValues) => {\n  const { locale: contextLocale } = useContext(IntlayerClientContext) ?? {};\n  const currentLocale = locale ?? contextLocale;\n\n  return useMemo<WrappedIntl>(() => bindIntl(currentLocale), [currentLocale]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,WAAW,WAA2B;CACjD,MAAM,EAAE,QAAQ,+CAA6BA,sDAAsB,IAAI,EAAE;CACzE,MAAM,gBAAgB,UAAU;AAEhC,gFAA2C,cAAc,EAAE,CAAC,cAAc,CAAC"}

package/dist/cjs/format/useList.cjs

@@ -27,7 +27,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * ```
 */
 const useList = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.list)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useList.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useList.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a list formatter\n * bound to the current application locale.\n *\n * @returns {(values: (string | number)[], options?: ListProps) => string}\n * A function to format arrays into localized list strings.\n *\n * @example\n * ```tsx\n * const formatList = useList();\n *\n * formatList(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * formatList(['red', 'green', 'blue'], { type: 'disjunction' });\n * // \"red, green, or blue\"\n *\n * formatList([1, 2, 3], { type: 'unit', locale: 'de-DE' });\n * // \"1, 2 und 3\"\n * ```\n */\nexport const useList = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof list>) =>\n      list(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,6CACG,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useList.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a list formatter\n * bound to the current application locale.\n *\n * @returns {(values: (string | number)[], options?: ListProps) => string}\n * A function to format arrays into localized list strings.\n *\n * @example\n * ```tsx\n * const formatList = useList();\n *\n * formatList(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * formatList(['red', 'green', 'blue'], { type: 'disjunction' });\n * // \"red, green, or blue\"\n *\n * formatList([1, 2, 3], { type: 'unit', locale: 'de-DE' });\n * // \"1, 2 und 3\"\n * ```\n */\nexport const useList = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof list>) =>\n      list(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,6CACG,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/useNumber.cjs

@@ -28,7 +28,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * A number formatting function bound to the active locale.
 */
 const useNumber = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.number)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useNumber.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a localized number formatter.\n *\n * Uses the current locale from {@link useLocaleBase} and returns\n * a function that can be used to format numbers consistently\n * according to the user's locale.\n *\n * @example\n * ```tsx\n * const formatNumber = useNumber();\n *\n * formatNumber(12345);\n * // e.g. \"12,345\" (en-US)\n * // e.g. \"12 345\" (fr-FR)\n *\n * formatNumber(0.75, { style: \"percent\" });\n * // e.g. \"75%\"\n * ```\n *\n * @returns {(value: string | number, options?: import(\"../createNumber\").NumberProps) => string}\n * A number formatting function bound to the active locale.\n */\nexport const useNumber = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof number>) =>\n      number(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,+CACK,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useNumber.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React client hook that provides a localized number formatter.\n *\n * Uses the current locale from {@link useLocaleBase} and returns\n * a function that can be used to format numbers consistently\n * according to the user's locale.\n *\n * @example\n * ```tsx\n * const formatNumber = useNumber();\n *\n * formatNumber(12345);\n * // e.g. \"12,345\" (en-US)\n * // e.g. \"12 345\" (fr-FR)\n *\n * formatNumber(0.75, { style: \"percent\" });\n * // e.g. \"75%\"\n * ```\n *\n * @returns {(value: string | number, options?: import(\"../createNumber\").NumberProps) => string}\n * A number formatting function bound to the active locale.\n */\nexport const useNumber = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof number>) =>\n      number(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,+CACK,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/usePercentage.cjs

@@ -24,7 +24,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * A function that formats numbers or numeric strings into localized percentages.
 */
 const usePercentage = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.percentage)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/usePercentage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React hook to provide a percentage formatter function\n * based on the current application locale.\n *\n * This hook retrieves the active locale using {@link useLocaleBase}\n * and memoizes a `createPercentage` instance for that locale.\n *\n * @example\n * ```tsx\n * const formatPercentage = usePercentage();\n *\n * const result = formatPercentage(0.875, { maximumFractionDigits: 1 });\n * // \"87.5%\" (depending on locale)\n * ```\n *\n * @returns {(value: string | number, options?: Omit<PercentageOptions, \"value\">) => string}\n * A function that formats numbers or numeric strings into localized percentages.\n */\nexport const usePercentage = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof percentage>) =>\n      percentage(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,sBAAsB;CACjC,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,mDACS,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"usePercentage.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React hook to provide a percentage formatter function\n * based on the current application locale.\n *\n * This hook retrieves the active locale using {@link useLocaleBase}\n * and memoizes a `createPercentage` instance for that locale.\n *\n * @example\n * ```tsx\n * const formatPercentage = usePercentage();\n *\n * const result = formatPercentage(0.875, { maximumFractionDigits: 1 });\n * // \"87.5%\" (depending on locale)\n * ```\n *\n * @returns {(value: string | number, options?: Omit<PercentageOptions, \"value\">) => string}\n * A function that formats numbers or numeric strings into localized percentages.\n */\nexport const usePercentage = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof percentage>) =>\n      percentage(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,sBAAsB;CACjC,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,mDACS,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/useRelativeTime.cjs

@@ -24,7 +24,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 *          bound to the current client locale.
 */
 const useRelativeTime = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.relativeTime)(args[0], args[1], {
 		...args[2],
 		locale: args[2]?.locale ?? locale

package/dist/cjs/format/useRelativeTime.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Client-side React hook for accessing a localized relative time formatter.\n *\n * This hook:\n * - Reads the current locale from {@link useLocaleBase}.\n * - Creates a new relative time formatter with {@link createRelativeTime}.\n * - Returns a function that can format time differences into localized strings.\n *\n * Example:\n * ```tsx\n * const relativeTime = useRelativeTime();\n * const formatted = relativeTime(new Date(\"2024-08-01\"), new Date());\n * // e.g., \"2 weeks ago\"\n * ```\n *\n * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function\n *          bound to the current client locale.\n */\nexport const useRelativeTime = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof relativeTime>) =>\n      relativeTime(args[0], args[1], {\n        ...args[2],\n        locale: args[2]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,wBAAwB;CACnC,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,qDACW,KAAK,IAAI,KAAK,IAAI;EAC7B,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useRelativeTime.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * Client-side React hook for accessing a localized relative time formatter.\n *\n * This hook:\n * - Reads the current locale from {@link useLocaleBase}.\n * - Creates a new relative time formatter with {@link createRelativeTime}.\n * - Returns a function that can format time differences into localized strings.\n *\n * Example:\n * ```tsx\n * const relativeTime = useRelativeTime();\n * const formatted = relativeTime(new Date(\"2024-08-01\"), new Date());\n * // e.g., \"2 weeks ago\"\n * ```\n *\n * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function\n *          bound to the current client locale.\n */\nexport const useRelativeTime = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof relativeTime>) =>\n      relativeTime(args[0], args[1], {\n        ...args[2],\n        locale: args[2]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,wBAAwB;CACnC,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,qDACW,KAAK,IAAI,KAAK,IAAI;EAC7B,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/format/useUnit.cjs

@@ -23,7 +23,7 @@ let _intlayer_core_formatters = require("@intlayer/core/formatters");
 * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
 */
 const useUnit = () => {
-	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext);
+	const { locale } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	return (0, preact_hooks.useCallback)((...args) => (0, _intlayer_core_formatters.units)(args[0], {
 		...args[1],
 		locale: args[1]?.locale ?? locale

package/dist/cjs/format/useUnit.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React hook that provides a unit formatting function\n * based on the current locale from {@link useLocaleBase}.\n *\n * This hook wraps {@link createUnit} to return a formatter\n * that can convert values into human-readable localized units\n * (e.g., \"10 km\", \"5 lbs\").\n *\n * @example\n * ```tsx\n * const formatUnit = useUnit();\n * const distance = formatUnit(10, { unit: \"kilometer\" });\n * // \"10 km\" (depending on locale)\n * ```\n *\n * @returns {Function} A unit formatting function that accepts a value and optional formatting options.\n */\nexport const useUnit = () => {\n  const { locale } = useContext(IntlayerClientContext);\n\n  return useCallback(\n    (...args: Parameters<typeof units>) =>\n      units(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB;AAEpD,uCACG,GAAG,8CACI,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}
+{"version":3,"file":"useUnit.cjs","names":["IntlayerClientContext"],"sources":["../../../src/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from '../client/IntlayerProvider';\n\n/**\n * React hook that provides a unit formatting function\n * based on the current locale from {@link useLocaleBase}.\n *\n * This hook wraps {@link createUnit} to return a formatter\n * that can convert values into human-readable localized units\n * (e.g., \"10 km\", \"5 lbs\").\n *\n * @example\n * ```tsx\n * const formatUnit = useUnit();\n * const distance = formatUnit(10, { unit: \"kilometer\" });\n * // \"10 km\" (depending on locale)\n * ```\n *\n * @returns {Function} A unit formatting function that accepts a value and optional formatting options.\n */\nexport const useUnit = () => {\n  const { locale } = useContext(IntlayerClientContext) ?? {};\n\n  return useCallback(\n    (...args: Parameters<typeof units>) =>\n      units(args[0], {\n        ...args[1],\n        locale: args[1]?.locale ?? locale,\n      }),\n    [locale]\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,wCAAsBA,sDAAsB,IAAI,EAAE;AAE1D,uCACG,GAAG,8CACI,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/cjs/html/HTMLRenderer.cjs

@@ -3,27 +3,20 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_html_HTMLProvider = require('./HTMLProvider.cjs');
 let _intlayer_core_interpreter = require("@intlayer/core/interpreter");
 let preact = require("preact");
-let _intlayer_core_transpiler = require("@intlayer/core/transpiler");
 
 //#region src/html/HTMLRenderer.tsx
-const createDefaultHTMLComponents = () => {
-	const components = {};
-	for (const tag of _intlayer_core_transpiler.HTML_TAGS) components[tag] = ({ children, ...props }) => (0, preact.h)(tag, props, children);
-	return components;
-};
-const defaultHTMLComponents = createDefaultHTMLComponents();
 /**
 * Renders HTML-like content to JSX with the provided components.
 *
 * This function does not use context from HTMLProvider. Use `useHTMLRenderer`
 * hook if you want to leverage provider context.
 */
-const renderHTML = (content, { components } = {}) => {
-	const mergedComponents = {
-		...defaultHTMLComponents,
-		...components
-	};
-	return (0, preact.h)(preact.Fragment, null, (0, _intlayer_core_interpreter.getHTML)(content, Object.fromEntries(Object.entries(mergedComponents).filter(([, Component]) => Component).map(([key, Component]) => [key, (props) => (0, preact.h)(Component, props)]))));
+const renderHTML = (content, { components = {} } = {}) => {
+	const userComponents = Object.fromEntries(Object.entries(components).filter(([, Component]) => Component).map(([key, Component]) => [key, (props) => (0, preact.h)(Component, props)]));
+	return (0, preact.h)(preact.Fragment, null, (0, _intlayer_core_interpreter.getHTML)(content, new Proxy(userComponents, { get(target, prop) {
+		if (typeof prop === "string" && prop in target) return target[prop];
+		if (typeof prop === "string" && /^[a-z][a-z0-9]*$/.test(prop)) return (props) => (0, preact.h)(prop, props);
+	} })));
 };
 /**
 * Hook that returns a function to render HTML content.
@@ -49,7 +42,6 @@ const HTMLRenderer = ({ children = "", html, components }) => {
 
 //#endregion
 exports.HTMLRenderer = HTMLRenderer;
-exports.defaultHTMLComponents = defaultHTMLComponents;
 exports.renderHTML = renderHTML;
 exports.useHTMLRenderer = useHTMLRenderer;
 //# sourceMappingURL=HTMLRenderer.cjs.map

package/dist/cjs/html/HTMLRenderer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.cjs","names":["HTML_TAGS","Fragment","useHTMLContext"],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["import { getHTML } from '@intlayer/core/interpreter';\nimport { HTML_TAGS } from '@intlayer/core/transpiler';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { Fragment, type FunctionComponent, h, type JSX } from 'preact';\nimport { useHTMLContext } from './HTMLProvider';\nimport type { HTMLComponents } from './types';\n\n/**\n * Type for Preact HTML tag components.\n */\ntype HTMLTagComponent = (props: {\n  children?: any;\n  [key: string]: any;\n}) => JSX.Element;\n\nconst createDefaultHTMLComponents = (): Record<string, HTMLTagComponent> => {\n  const components: Record<string, HTMLTagComponent> = {};\n\n  for (const tag of HTML_TAGS) {\n    components[tag] = ({ children, ...props }) =>\n      h(tag as any, props, children);\n  }\n\n  return components;\n};\n\nexport const defaultHTMLComponents = createDefaultHTMLComponents();\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components }: RenderHTMLProps = {}\n): JSX.Element => {\n  const mergedComponents = {\n    ...defaultHTMLComponents,\n    ...components,\n  };\n\n  // Wrap all components to ensure they are rendered via Preact's h\n  const wrappedComponents = Object.fromEntries(\n    Object.entries(mergedComponents)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => h(Component as any, props),\n      ])\n  );\n\n  return h(Fragment, null, getHTML(content, wrappedComponents));\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children?: string;\n  /**\n   * Alias for children, used by the plugin.\n   */\n  html?: string;\n  /**\n   * Alias for components, used by the plugin.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  dictionaryKey?: string;\n  keyPath?: KeyPath[];\n};\n\n/**\n * Preact component that renders HTML-like content to JSX.\n */\nexport const HTMLRenderer: FunctionComponent<HTMLRendererProps> = ({\n  children = '',\n  html,\n  components,\n}) => {\n  const render = useHTMLRenderer({ components: components });\n  const content = children || html || '';\n\n  return render(content);\n};\n"],"mappings":";;;;;;;;AAeA,MAAM,oCAAsE;CAC1E,MAAM,aAA+C,EAAE;AAEvD,MAAK,MAAM,OAAOA,oCAChB,YAAW,QAAQ,EAAE,UAAU,GAAG,0BAC9B,KAAY,OAAO,SAAS;AAGlC,QAAO;;AAGT,MAAa,wBAAwB,6BAA6B;;;;;;;AAgBlE,MAAa,cACX,SACA,EAAE,eAAgC,EAAE,KACpB;CAChB,MAAM,mBAAmB;EACvB,GAAG;EACH,GAAG;EACJ;AAYD,sBAASC,iBAAU,8CAAc,SATP,OAAO,YAC/B,OAAO,QAAQ,iBAAiB,CAC7B,QAAQ,GAAG,eAAe,UAAU,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,wBAAiB,WAAkB,MAAM,CAC3C,CAAC,CACL,CAE2D,CAAC;;;;;;;;AAS/D,MAAa,mBAAmB,EAAE,eAAgC,EAAE,KAAK;CACvE,MAAM,UAAUC,0CAAgB;AAEhC,SAAQ,YAAoB;AAC1B,SAAO,WAAW,SAAS,EACzB,YAAY;GACV,GAAG,SAAS;GACZ,GAAG;GACJ,EACF,CAAC;;;;;;AAwBN,MAAa,gBAAsD,EACjE,WAAW,IACX,MACA,iBACI;AAIJ,QAHe,gBAAgB,EAAc,YAAY,CAAC,CAC1C,YAAY,QAAQ,GAEd"}
+{"version":3,"file":"HTMLRenderer.cjs","names":["Fragment","useHTMLContext"],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["import { getHTML } from '@intlayer/core/interpreter';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { Fragment, type FunctionComponent, h, type JSX } from 'preact';\nimport { useHTMLContext } from './HTMLProvider';\nimport type { HTMLComponents } from './types';\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components = {} }: RenderHTMLProps = {}\n): JSX.Element => {\n  // Wrap explicit user components to ensure they are rendered via Preact's h\n  const userComponents = Object.fromEntries(\n    Object.entries(components)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => h(Component as any, props),\n      ])\n  );\n\n  // Proxy handles standard HTML tags lazily without a hardcoded list\n  const wrappedComponents = new Proxy(userComponents, {\n    get(target, prop) {\n      if (typeof prop === 'string' && prop in target) {\n        return target[prop];\n      }\n      // Fallback: Lazily generate a wrapper for standard lowercase HTML tags\n      if (typeof prop === 'string' && /^[a-z][a-z0-9]*$/.test(prop)) {\n        return (props: any) => h(prop, props);\n      }\n      return undefined;\n    },\n  });\n\n  // Cast wrappedComponents to any to satisfy getHTML's dictionary typing\n  return h(Fragment, null, getHTML(content, wrappedComponents as any));\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children?: string;\n  /**\n   * Alias for children, used by the plugin.\n   */\n  html?: string;\n  /**\n   * Alias for components, used by the plugin.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  dictionaryKey?: string;\n  keyPath?: KeyPath[];\n};\n\n/**\n * Preact component that renders HTML-like content to JSX.\n */\nexport const HTMLRenderer: FunctionComponent<HTMLRendererProps> = ({\n  children = '',\n  html,\n  components,\n}) => {\n  const render = useHTMLRenderer({ components });\n  const content = children || html || '';\n\n  return render(content);\n};\n"],"mappings":";;;;;;;;;;;;;AAoBA,MAAa,cACX,SACA,EAAE,aAAa,EAAE,KAAsB,EAAE,KACzB;CAEhB,MAAM,iBAAiB,OAAO,YAC5B,OAAO,QAAQ,WAAW,CACvB,QAAQ,GAAG,eAAe,UAAU,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,wBAAiB,WAAkB,MAAM,CAC3C,CAAC,CACL;AAiBD,sBAASA,iBAAU,8CAAc,SAdP,IAAI,MAAM,gBAAgB,EAClD,IAAI,QAAQ,MAAM;AAChB,MAAI,OAAO,SAAS,YAAY,QAAQ,OACtC,QAAO,OAAO;AAGhB,MAAI,OAAO,SAAS,YAAY,mBAAmB,KAAK,KAAK,CAC3D,SAAQ,wBAAiB,MAAM,MAAM;IAI1C,CAAC,CAGiE,CAAC;;;;;;;;AAStE,MAAa,mBAAmB,EAAE,eAAgC,EAAE,KAAK;CACvE,MAAM,UAAUC,0CAAgB;AAEhC,SAAQ,YAAoB;AAC1B,SAAO,WAAW,SAAS,EACzB,YAAY;GACV,GAAG,SAAS;GACZ,GAAG;GACJ,EACF,CAAC;;;;;;AAwBN,MAAa,gBAAsD,EACjE,WAAW,IACX,MACA,iBACI;AAIJ,QAHe,gBAAgB,EAAE,YAAY,CAAC,CAC9B,YAAY,QAAQ,GAEd"}