react-intlayer 8.4.3 → 8.4.5

package/dist/esm/client/format/useDate.mjs

@@ -1,2 +1,44 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useContext as t}from"react";import{date as n}from"@intlayer/core/formatters";const r=()=>{let{locale:r}=t(e);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as useDate};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useContext } from "react";
+import { date } from "@intlayer/core/formatters";
+
+//#region src/client/format/useDate.ts
+/**
+* React client hook that provides a localized date/time formatter
+* bound to the current application locale.
+*
+* @returns {(date: Date | string | number, options?: DateProps) => string}
+* A function to format dates or timestamps into localized date/time strings.
+*
+* @example
+* ```tsx
+* const formatDate = useDate();
+*
+* formatDate(new Date("2025-01-01"));
+* // "Jan 1, 2025"
+*
+* formatDate("2025-01-01T15:30:00Z", {
+*   dateStyle: "full",
+*   timeStyle: "short",
+* });
+* // "Wednesday, January 1, 2025 at 3:30 PM"
+*
+* formatDate(1735689600000, { locale: "fr-FR", dateStyle: "long" });
+* // "1 janvier 2025"
+* ```
+*
+* @see createDate
+*/
+const useDate = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return (...args) => date(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useDate };
 //# sourceMappingURL=useDate.mjs.map

package/dist/esm/client/format/useDate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.mjs","names":[],"sources":["../../../../src/client/format/useDate.ts"],"sourcesContent":["'use client';\n\nimport { date } from '@intlayer/core/formatters';\nimport { useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"iKAgCA,MAAa,MAAgB,CAC3B,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAQ,GAAG,IACT,EAAK,EAAK,GAAI,CACZ,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useDate.mjs","names":[],"sources":["../../../../src/client/format/useDate.ts"],"sourcesContent":["'use client';\n\nimport { date } from '@intlayer/core/formatters';\nimport { useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,SAAQ,GAAG,SACT,KAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

package/dist/esm/client/format/useIntl.mjs

@@ -1,2 +1,44 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useContext as t,useMemo as n}from"react";import{bindIntl as r}from"@intlayer/core/formatters";const i=i=>{let{locale:a}=t(e),o=i??a;return n(()=>r(o),[o])};export{i as useIntl};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useContext, useMemo } from "react";
+import { bindIntl } from "@intlayer/core/formatters";
+
+//#region src/client/format/useIntl.ts
+/**
+* React client hook that provides a locale-bound `Intl` object.
+*
+* It acts exactly like the native `Intl` object, but acts as a proxy to:
+* 1. Inject the current locale automatically if none is provided.
+* 2. Use the performance-optimized `CachedIntl` under the hood.
+*
+* @example
+* ```tsx
+* const intl = useIntl(); // uses context locale
+*
+* // Standard API, but no need to pass 'en-US' as the first argument
+* const formatted = new intl.NumberFormat({
+* style: 'currency',
+* currency: 'USD'
+* }).format(123.45);
+* ```
+*
+* @example
+* ```tsx
+* const intl = useIntl();
+*
+* // You can still override the locale if needed
+* const date = new intl.DateTimeFormat({ locale: 'fr-FR' }).format(new Date());
+* // or
+* const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());
+* ```
+*/
+const useIntl = (locale) => {
+	const { locale: contextLocale } = useContext(IntlayerClientContext);
+	const currentLocale = locale ?? contextLocale;
+	return useMemo(() => bindIntl(currentLocale), [currentLocale]);
+};
+
+//#endregion
+export { useIntl };
 //# sourceMappingURL=useIntl.mjs.map

package/dist/esm/client/format/useIntl.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.mjs","names":[],"sources":["../../../../src/client/format/useIntl.ts"],"sourcesContent":["'use client';\n\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from '../IntlayerProvider';\n\n/**\n * React 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 'en-US' as the first argument\n * const formatted = new intl.NumberFormat({\n * style: 'currency',\n * currency: 'USD'\n * }).format(123.45);\n * ```\n *\n * @example\n * ```tsx\n * const intl = useIntl();\n *\n * // You can still override the locale if needed\n * const date = new intl.DateTimeFormat({ locale: 'fr-FR' }).format(new Date());\n * // or\n * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());\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":"kLAmCA,MAAa,EAAW,GAA2B,CACjD,GAAM,CAAE,OAAQ,GAAkB,EAAW,EAAsB,CAC7D,EAAgB,GAAU,EAEhC,OAAO,MAA2B,EAAS,EAAc,CAAE,CAAC,EAAc,CAAC"}
+{"version":3,"file":"useIntl.mjs","names":[],"sources":["../../../../src/client/format/useIntl.ts"],"sourcesContent":["'use client';\n\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\nimport { IntlayerClientContext } from '../IntlayerProvider';\n\n/**\n * React 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 'en-US' as the first argument\n * const formatted = new intl.NumberFormat({\n * style: 'currency',\n * currency: 'USD'\n * }).format(123.45);\n * ```\n *\n * @example\n * ```tsx\n * const intl = useIntl();\n *\n * // You can still override the locale if needed\n * const date = new intl.DateTimeFormat({ locale: 'fr-FR' }).format(new Date());\n * // or\n * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,WAAW,WAA2B;CACjD,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB;CACnE,MAAM,gBAAgB,UAAU;AAEhC,QAAO,cAA2B,SAAS,cAAc,EAAE,CAAC,cAAc,CAAC"}

package/dist/esm/client/format/useList.mjs

@@ -1,2 +1,39 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useCallback as t,useContext as n}from"react";import{list as r}from"@intlayer/core/formatters";const i=()=>{let{locale:i}=n(e);return t((...e)=>r(e[0],{...e[1],locale:e[1]?.locale??i}),[i])};export{i as useList};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useCallback, useContext } from "react";
+import { list } from "@intlayer/core/formatters";
+
+//#region src/client/format/useList.ts
+/**
+* React client hook that provides a list formatter
+* bound to the current application locale.
+*
+* @returns {(values: (string | number)[], options?: ListProps) => string}
+* A function to format arrays into localized list strings.
+*
+* @example
+* ```tsx
+* const formatList = useList();
+*
+* formatList(['apple', 'banana', 'orange']);
+* // "apple, banana, and orange"
+*
+* formatList(['red', 'green', 'blue'], { type: 'disjunction' });
+* // "red, green, or blue"
+*
+* formatList([1, 2, 3], { type: 'unit', locale: 'de-DE' });
+* // "1, 2 und 3"
+* ```
+*/
+const useList = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return useCallback((...args) => list(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	}), [locale]);
+};
+
+//#endregion
+export { useList };
 //# sourceMappingURL=useList.mjs.map

package/dist/esm/client/format/useList.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useList.mjs","names":[],"sources":["../../../../src/client/format/useList.ts"],"sourcesContent":["'use client';\n\nimport { list } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"kLA2BA,MAAa,MAAgB,CAC3B,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAO,GACJ,GAAG,IACF,EAAK,EAAK,GAAI,CACZ,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC,CACJ,CAAC,EAAO,CACT"}
+{"version":3,"file":"useList.mjs","names":[],"sources":["../../../../src/client/format/useList.ts"],"sourcesContent":["'use client';\n\nimport { list } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,QAAO,aACJ,GAAG,SACF,KAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/esm/client/format/useNumber.mjs

@@ -1,2 +1,40 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useCallback as t,useContext as n}from"react";import{number as r}from"@intlayer/core/formatters";const i=()=>{let{locale:i}=n(e);return t((...e)=>r(e[0],{...e[1],locale:e[1]?.locale??i}),[i])};export{i as useNumber};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useCallback, useContext } from "react";
+import { number } from "@intlayer/core/formatters";
+
+//#region src/client/format/useNumber.ts
+/**
+* React client hook that provides a localized number formatter.
+*
+* Uses the current locale from {@link useLocaleBase} and returns
+* a function that can be used to format numbers consistently
+* according to the user's locale.
+*
+* @example
+* ```tsx
+* const formatNumber = useNumber();
+*
+* formatNumber(12345);
+* // e.g. "12,345" (en-US)
+* // e.g. "12 345" (fr-FR)
+*
+* formatNumber(0.75, { style: "percent" });
+* // e.g. "75%"
+* ```
+*
+* @returns {(value: string | number, options?: import("../createNumber").NumberProps) => string}
+* A number formatting function bound to the active locale.
+*/
+const useNumber = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return useCallback((...args) => number(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	}), [locale]);
+};
+
+//#endregion
+export { useNumber };
 //# sourceMappingURL=useNumber.mjs.map

package/dist/esm/client/format/useNumber.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.mjs","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"sourcesContent":["'use client';\n\nimport { number } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"oLA4BA,MAAa,MAAkB,CAC7B,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAO,GACJ,GAAG,IACF,EAAO,EAAK,GAAI,CACd,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC,CACJ,CAAC,EAAO,CACT"}
+{"version":3,"file":"useNumber.mjs","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"sourcesContent":["'use client';\n\nimport { number } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,kBAAkB;CAC7B,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,QAAO,aACJ,GAAG,SACF,OAAO,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/esm/client/format/usePercentage.mjs

@@ -1,2 +1,36 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useCallback as t,useContext as n}from"react";import{percentage as r}from"@intlayer/core/formatters";const i=()=>{let{locale:i}=n(e);return t((...e)=>r(e[0],{...e[1],locale:e[1]?.locale??i}),[i])};export{i as usePercentage};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useCallback, useContext } from "react";
+import { percentage } from "@intlayer/core/formatters";
+
+//#region src/client/format/usePercentage.ts
+/**
+* React hook to provide a percentage formatter function
+* based on the current application locale.
+*
+* This hook retrieves the active locale using {@link useLocaleBase}
+* and memoizes a `createPercentage` instance for that locale.
+*
+* @example
+* ```tsx
+* const formatPercentage = usePercentage();
+*
+* const result = formatPercentage(0.875, { maximumFractionDigits: 1 });
+* // "87.5%" (depending on locale)
+* ```
+*
+* @returns {(value: string | number, options?: Omit<PercentageOptions, "value">) => string}
+* A function that formats numbers or numeric strings into localized percentages.
+*/
+const usePercentage = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return useCallback((...args) => percentage(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	}), [locale]);
+};
+
+//#endregion
+export { usePercentage };
 //# sourceMappingURL=usePercentage.mjs.map

package/dist/esm/client/format/usePercentage.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.mjs","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"sourcesContent":["'use client';\n\nimport { percentage } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"wLAwBA,MAAa,MAAsB,CACjC,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAO,GACJ,GAAG,IACF,EAAW,EAAK,GAAI,CAClB,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC,CACJ,CAAC,EAAO,CACT"}
+{"version":3,"file":"usePercentage.mjs","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"sourcesContent":["'use client';\n\nimport { percentage } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,sBAAsB;CACjC,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,QAAO,aACJ,GAAG,SACF,WAAW,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/esm/client/format/useRelativeTime.mjs

@@ -1,2 +1,36 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useCallback as t,useContext as n}from"react";import{relativeTime as r}from"@intlayer/core/formatters";const i=()=>{let{locale:i}=n(e);return t((...e)=>r(e[0],e[1],{...e[2],locale:e[2]?.locale??i}),[i])};export{i as useRelativeTime};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useCallback, useContext } from "react";
+import { relativeTime } from "@intlayer/core/formatters";
+
+//#region src/client/format/useRelativeTime.ts
+/**
+* Client-side React hook for accessing a localized relative time formatter.
+*
+* This hook:
+* - Reads the current locale from {@link useLocaleBase}.
+* - Creates a new relative time formatter with {@link createRelativeTime}.
+* - Returns a function that can format time differences into localized strings.
+*
+* Example:
+* ```tsx
+* const relativeTime = useRelativeTime();
+* const formatted = relativeTime(new Date("2024-08-01"), new Date());
+* // e.g., "2 weeks ago"
+* ```
+*
+* @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function
+*          bound to the current client locale.
+*/
+const useRelativeTime = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return useCallback((...args) => relativeTime(args[0], args[1], {
+		...args[2],
+		locale: args[2]?.locale ?? locale
+	}), [locale]);
+};
+
+//#endregion
+export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.mjs.map

package/dist/esm/client/format/useRelativeTime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.mjs","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"sourcesContent":["'use client';\n\nimport { relativeTime } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"0LAwBA,MAAa,MAAwB,CACnC,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAO,GACJ,GAAG,IACF,EAAa,EAAK,GAAI,EAAK,GAAI,CAC7B,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC,CACJ,CAAC,EAAO,CACT"}
+{"version":3,"file":"useRelativeTime.mjs","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"sourcesContent":["'use client';\n\nimport { relativeTime } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,wBAAwB;CACnC,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,QAAO,aACJ,GAAG,SACF,aAAa,KAAK,IAAI,KAAK,IAAI;EAC7B,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/esm/client/format/useUnit.mjs

@@ -1,2 +1,35 @@
-"use client";import{IntlayerClientContext as e}from"../IntlayerProvider.mjs";import{useCallback as t,useContext as n}from"react";import{units as r}from"@intlayer/core/formatters";const i=()=>{let{locale:i}=n(e);return t((...e)=>r(e[0],{...e[1],locale:e[1]?.locale??i}),[i])};export{i as useUnit};
+'use client';
+
+import { IntlayerClientContext } from "../IntlayerProvider.mjs";
+import { useCallback, useContext } from "react";
+import { units } from "@intlayer/core/formatters";
+
+//#region src/client/format/useUnit.ts
+/**
+* React hook that provides a unit formatting function
+* based on the current locale from {@link useLocaleBase}.
+*
+* This hook wraps {@link createUnit} to return a formatter
+* that can convert values into human-readable localized units
+* (e.g., "10 km", "5 lbs").
+*
+* @example
+* ```tsx
+* const formatUnit = useUnit();
+* const distance = formatUnit(10, { unit: "kilometer" });
+* // "10 km" (depending on locale)
+* ```
+*
+* @returns {Function} A unit formatting function that accepts a value and optional formatting options.
+*/
+const useUnit = () => {
+	const { locale } = useContext(IntlayerClientContext);
+	return useCallback((...args) => units(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	}), [locale]);
+};
+
+//#endregion
+export { useUnit };
 //# sourceMappingURL=useUnit.mjs.map

package/dist/esm/client/format/useUnit.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.mjs","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"sourcesContent":["'use client';\n\nimport { units } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":"mLAuBA,MAAa,MAAgB,CAC3B,GAAM,CAAE,UAAW,EAAW,EAAsB,CAEpD,OAAO,GACJ,GAAG,IACF,EAAM,EAAK,GAAI,CACb,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC,CACJ,CAAC,EAAO,CACT"}
+{"version":3,"file":"useUnit.mjs","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"sourcesContent":["'use client';\n\nimport { units } from '@intlayer/core/formatters';\nimport { useCallback, useContext } from 'react';\nimport { IntlayerClientContext } from '../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":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,gBAAgB;CAC3B,MAAM,EAAE,WAAW,WAAW,sBAAsB;AAEpD,QAAO,aACJ,GAAG,SACF,MAAM,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC,EACJ,CAAC,OAAO,CACT"}

package/dist/esm/client/index.mjs

@@ -1 +1,14 @@
-import{localeCookie as e,localeInStorage as t,setLocaleCookie as n,setLocaleInStorage as r,useLocaleCookie as i,useLocaleStorage as a}from"./useLocaleStorage.mjs";import{IntlayerClientContext as o,IntlayerProvider as s,IntlayerProviderContent as c,useIntlayerContext as l}from"./IntlayerProvider.mjs";import{t as u}from"./t.mjs";import{useDictionary as d}from"./useDictionary.mjs";import{useDictionaryAsync as f}from"./useDictionaryAsync.mjs";import{useLoadDynamic as p}from"./useLoadDynamic.mjs";import{useDictionaryDynamic as m}from"./useDictionaryDynamic.mjs";import{useI18n as h}from"./useI18n.mjs";import{useIntlayer as g}from"./useIntlayer.mjs";import{useLocale as _}from"./useLocale.mjs";import{useLocaleBase as v}from"./useLocaleBase.mjs";import{useRewriteURL as y}from"./useRewriteURL.mjs";export{o as IntlayerClientContext,s as IntlayerProvider,c as IntlayerProviderContent,e as localeCookie,t as localeInStorage,n as setLocaleCookie,r as setLocaleInStorage,u as t,d as useDictionary,f as useDictionaryAsync,m as useDictionaryDynamic,h as useI18n,g as useIntlayer,l as useIntlayerContext,p as useLoadDynamic,_ as useLocale,v as useLocaleBase,i as useLocaleCookie,a as useLocaleStorage,y as useRewriteURL};
+import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./useLocaleStorage.mjs";
+import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, useIntlayerContext } from "./IntlayerProvider.mjs";
+import { t } from "./t.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useDictionaryAsync } from "./useDictionaryAsync.mjs";
+import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.mjs";
+import { useI18n } from "./useI18n.mjs";
+import { useIntlayer } from "./useIntlayer.mjs";
+import { useLocale } from "./useLocale.mjs";
+import { useLocaleBase } from "./useLocaleBase.mjs";
+import { useRewriteURL } from "./useRewriteURL.mjs";
+
+export { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, useRewriteURL };

package/dist/esm/client/t.mjs

@@ -1,2 +1,39 @@
-"use client";import{IntlayerClientContext as e}from"./IntlayerProvider.mjs";import{getTranslation as t}from"@intlayer/core/interpreter";import{useContext as n}from"react";const r=(r,i)=>{let{locale:a}=n(e);return t(r,i??a)};export{r as t};
+'use client';
+
+import { IntlayerClientContext } from "./IntlayerProvider.mjs";
+import { getTranslation } from "@intlayer/core/interpreter";
+import { useContext } from "react";
+
+//#region src/client/t.ts
+/**
+* Client-side translation function that returns the translation of the provided multilang content.
+*
+* If the locale is not provided, it will use the locale from the client context.
+*
+* @param multilangContent - An object mapping locales to their respective content.
+* @param locale - Optional locale to override the current context locale.
+* @returns The translation for the specified locale.
+*
+* @example
+* ```tsx
+* import { t } from 'react-intlayer';
+*
+* const MyComponent = () => {
+*   const greeting = t({
+*     en: 'Hello',
+*     fr: 'Bonjour',
+*     es: 'Hola',
+*   });
+*
+*   return <h1>{greeting}</h1>;
+* };
+* ```
+*/
+const t = (multilangContent, locale) => {
+	const { locale: currentLocale } = useContext(IntlayerClientContext);
+	return getTranslation(multilangContent, locale ?? currentLocale);
+};
+
+//#endregion
+export { t };
 //# sourceMappingURL=t.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.mjs","names":[],"sources":["../../../src/client/t.ts"],"sourcesContent":["'use client';\n\nimport { getTranslation } from '@intlayer/core/interpreter';\nimport type { LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side translation function that 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 *\n * @param multilangContent - An object mapping locales to their respective content.\n * @param locale - Optional locale to override the current context locale.\n * @returns The translation for the specified locale.\n *\n * @example\n * ```tsx\n * import { t } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const greeting = t({\n *     en: 'Hello',\n *     fr: 'Bonjour',\n *     es: 'Hola',\n *   });\n *\n *   return <h1>{greeting}</h1>;\n * };\n * ```\n */\nexport const t = <Content = string>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":"2KA+BA,MAAa,GACX,EACA,IACG,CACH,GAAM,CAAE,OAAQ,GAAkB,EAAW,EAAsB,CAGnE,OAAO,EAAwB,EAFV,GAAU,EAE+B"}
+{"version":3,"file":"t.mjs","names":[],"sources":["../../../src/client/t.ts"],"sourcesContent":["'use client';\n\nimport { getTranslation } from '@intlayer/core/interpreter';\nimport type { LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useContext } from 'react';\nimport { IntlayerClientContext } from './IntlayerProvider';\n\n/**\n * Client-side translation function that 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 *\n * @param multilangContent - An object mapping locales to their respective content.\n * @param locale - Optional locale to override the current context locale.\n * @returns The translation for the specified locale.\n *\n * @example\n * ```tsx\n * import { t } from 'react-intlayer';\n *\n * const MyComponent = () => {\n *   const greeting = t({\n *     en: 'Hello',\n *     fr: 'Bonjour',\n *     es: 'Hola',\n *   });\n *\n *   return <h1>{greeting}</h1>;\n * };\n * ```\n */\nexport const t = <Content = string>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: LocalesValues\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,KACX,kBACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB;AAGnE,QAAO,eAAwB,kBAFV,UAAU,cAE+B"}

package/dist/esm/client/useDictionary.mjs

@@ -1,2 +1,26 @@
-"use client";import{getDictionary as e}from"../getDictionary.mjs";import{IntlayerClientContext as t}from"./IntlayerProvider.mjs";import{useContext as n,useMemo as r}from"react";const i=(i,a)=>{let{locale:o}=n(t);return r(()=>e(i,a??o),[i.key,o,a])};export{i as useDictionary};
+'use client';
+
+import { getDictionary } from "../getDictionary.mjs";
+import { IntlayerClientContext } from "./IntlayerProvider.mjs";
+import { useContext, useMemo } from "react";
+
+//#region src/client/useDictionary.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the client context
+*/
+const useDictionary = (dictionary, locale) => {
+	const { locale: currentLocale } = useContext(IntlayerClientContext);
+	return useMemo(() => {
+		return getDictionary(dictionary, locale ?? currentLocale);
+	}, [
+		dictionary.key,
+		currentLocale,
+		locale
+	]);
+};
+
+//#endregion
+export { useDictionary };
 //# sourceMappingURL=useDictionary.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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":"iLAgBA,MAAa,GAIX,EACA,IACG,CACH,GAAM,CAAE,OAAQ,GAAkB,EAAW,EAAsB,CAEnE,OAAO,MAGE,EAAoB,EAFN,GAAU,EAE0B,CACxD,CAAC,EAAW,IAAK,EAAe,EAAO,CAAC"}
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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":";;;;;;;;;;;;AAgBA,MAAa,iBAIX,YACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB;AAEnE,QAAO,cAAc;AAGnB,SAAO,cAAoB,YAFN,UAAU,cAE0B;IACxD;EAAC,WAAW;EAAK;EAAe;EAAO,CAAC"}

package/dist/esm/client/useDictionaryAsync.mjs

@@ -1,2 +1,22 @@
-"use client";import{IntlayerClientContext as e}from"./IntlayerProvider.mjs";import{useDictionary as t}from"./useDictionary.mjs";import n from"@intlayer/config/built";import{useContext as r,useMemo as i}from"react";const a=async(a,o)=>{let{locale:s}=r(e),c=i(()=>o??s??n?.internationalization.defaultLocale,[s,o]);return t(await i(async()=>await a[c]?.(),[a,c]),c)};export{a as useDictionaryAsync};
+'use client';
+
+import { IntlayerClientContext } from "./IntlayerProvider.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import configuration from "@intlayer/config/built";
+import { useContext, useMemo } from "react";
+
+//#region src/client/useDictionaryAsync.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the client context
+*/
+const useDictionaryAsync = async (dictionaryPromise, locale) => {
+	const { locale: currentLocale } = useContext(IntlayerClientContext);
+	const localeTarget = useMemo(() => locale ?? currentLocale ?? configuration?.internationalization.defaultLocale, [currentLocale, locale]);
+	return useDictionary(await useMemo(async () => await dictionaryPromise[localeTarget]?.(), [dictionaryPromise, localeTarget]), localeTarget);
+};
+
+//#endregion
+export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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 <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\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<T, L>(dictionary, localeTarget as L) as any;\n};\n"],"mappings":"sNAkBA,MAAa,EAAqB,MAIhC,EACA,IACe,CACf,GAAM,CAAE,OAAQ,GAAkB,EAAW,EAAsB,CAE7D,EAAe,MAEjB,GACA,GACA,GAAe,qBAAqB,cACtC,CAAC,EAAe,EAAO,CACxB,CAUD,OAAO,EARY,MAAM,EACvB,SACG,MAAM,EACL,MACG,CACP,CAAC,EAAmB,EAAa,CAClC,CAEsC,EAAkB"}
+{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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 <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\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<T, L>(dictionary, localeTarget as L) as any;\n};\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAa,qBAAqB,OAIhC,mBACA,WACe;CACf,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB;CAEnE,MAAM,eAAe,cAEjB,UACA,iBACA,eAAe,qBAAqB,eACtC,CAAC,eAAe,OAAO,CACxB;AAUD,QAAO,cARY,MAAM,QACvB,YACG,MAAM,kBACL,iBACG,EACP,CAAC,mBAAmB,aAAa,CAClC,EAEsC,aAAkB"}

package/dist/esm/client/useDictionaryDynamic.mjs

@@ -1,2 +1,23 @@
-"use client";import{IntlayerClientContext as e}from"./IntlayerProvider.mjs";import{useDictionary as t}from"./useDictionary.mjs";import{useLoadDynamic as n}from"./useLoadDynamic.mjs";import r from"@intlayer/config/built";import{useContext as i,useMemo as a}from"react";const o=(o,s,c)=>{let{locale:l}=i(e),u=a(()=>c??l??r?.internationalization.defaultLocale,[l,c]);return t(n(`${String(s)}.${u}`,o[u]?.()),u)};export{o as useDictionaryDynamic};
+'use client';
+
+import { IntlayerClientContext } from "./IntlayerProvider.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import configuration from "@intlayer/config/built";
+import { useContext, useMemo } from "react";
+
+//#region src/client/useDictionaryDynamic.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the client context
+*/
+const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
+	const { locale: currentLocale } = useContext(IntlayerClientContext);
+	const localeTarget = useMemo(() => locale ?? currentLocale ?? configuration?.internationalization.defaultLocale, [currentLocale, locale]);
+	return useDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+};
+
+//#endregion
+export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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    () =>\n      locale ??\n      currentLocale ??\n      configuration?.internationalization.defaultLocale,\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":"4QAmBA,MAAa,GAIX,EACA,EACA,IACG,CACH,GAAM,CAAE,OAAQ,GAAkB,EAAW,EAAsB,CAC7D,EAAe,MAEjB,GACA,GACA,GAAe,qBAAqB,cACtC,CAAC,EAAe,EAAO,CACxB,CAOD,OAAO,EALY,EACjB,GAAG,OAAO,EAAI,CAAC,GAAG,IACjB,EAA0B,MAAiB,CAC7C,CAEgC,EAAa"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { useContext, useMemo } from 'react';\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    () =>\n      locale ??\n      currentLocale ??\n      configuration?.internationalization.defaultLocale,\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":";;;;;;;;;;;;;;AAmBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,EAAE,QAAQ,kBAAkB,WAAW,sBAAsB;CACnE,MAAM,eAAe,cAEjB,UACA,iBACA,eAAe,qBAAqB,eACtC,CAAC,eAAe,OAAO,CACxB;AAOD,QAAO,cALY,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAC7C,EAEgC,aAAa"}

package/dist/esm/client/useI18n.mjs

@@ -1,2 +1,44 @@
-"use client";import{IntlayerClientContext as e}from"./IntlayerProvider.mjs";import{getIntlayer as t}from"@intlayer/core/interpreter";import{useContext as n,useMemo as r}from"react";const i=(i,a)=>{let{locale:o}=n(e),s=r(()=>a??o,[o,a]),c=r(()=>t(i,s),[i,s]);return e=>{if(!e)return c;let t=e.split(`.`),n=c;for(let e of t)if(n=n?.[e],n===void 0)return c;return n}};export{i as useI18n};
+'use client';
+
+import { IntlayerClientContext } from "./IntlayerProvider.mjs";
+import { getIntlayer } from "@intlayer/core/interpreter";
+import { useContext, useMemo } from "react";
+
+//#region src/client/useI18n.ts
+/**
+* Hook that provides a translation function `t()` for accessing nested content by key.
+* This hook mimics the pattern found in libraries like i18next, next-intl, and vue-i18n.
+*
+* @param namespace - The dictionary key to scope translations to
+* @param locale - Optional locale override. If not provided, uses the current context locale
+* @returns A translation function `t(key)` that returns the translated content for the given key
+*
+* @example
+* ```tsx
+* const t = useI18n('IndexPage');
+* const title = t('title'); // Returns translated string for 'IndexPage.title'
+* const nestedContent = t('section.subtitle'); // Returns 'IndexPage.section.subtitle'
+* // For attributes like `aria-label`, use `.value` to get the plain string
+* const ariaLabel = t('button.ariaLabel').value; // 'Close modal'
+* ```
+*/
+const useI18n = (namespace, locale) => {
+	const { locale: currentLocale } = useContext(IntlayerClientContext);
+	const localeTarget = useMemo(() => locale ?? currentLocale, [currentLocale, locale]);
+	const dictionaryContent = useMemo(() => getIntlayer(namespace, localeTarget), [namespace, localeTarget]);
+	const t = (path) => {
+		if (!path) return dictionaryContent;
+		const pathArray = path.split(".");
+		let current = dictionaryContent;
+		for (const key of pathArray) {
+			current = current?.[key];
+			if (current === void 0) return dictionaryContent;
+		}
+		return current;
+	};
+	return t;
+};
+
+//#endregion
+export { useI18n };
 //# sourceMappingURL=useI18n.mjs.map