react-intlayer 8.4.3 → 8.4.5

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

@@ -1,2 +1,42 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{date as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as useDate};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { date } from "@intlayer/core/formatters";
+
+//#region src/server/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 = getServerContext(IntlayerServerContext);
+	return (...args) => date(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useDate };
 //# sourceMappingURL=useDate.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDate.mjs","names":[],"sources":["../../../../src/server/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":"+KA+BA,MAAa,MAAgB,CAC3B,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAK,EAAK,GAAI,CACZ,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useDate.mjs","names":[],"sources":["../../../../src/server/format/useDate.ts"],"sourcesContent":["import { date } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof date>) =>\n    date(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,KAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

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

@@ -1,2 +1,42 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import n from"@intlayer/config/built";import{bindIntl as r}from"@intlayer/core/formatters";const i=i=>{let a=e(t);return r(i??a??n?.internationalization?.defaultLocale)};export{i as useIntl};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import configuration from "@intlayer/config/built";
+import { bindIntl } from "@intlayer/core/formatters";
+
+//#region src/server/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 currentLocale = getServerContext(IntlayerServerContext);
+	return bindIntl(locale ?? currentLocale ?? configuration?.internationalization?.defaultLocale);
+};
+
+//#endregion
+export { useIntl };
 //# sourceMappingURL=useIntl.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntl.mjs","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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): WrappedIntl => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return bindIntl(\n    locale ??\n      currentLocale ??\n      configuration?.internationalization?.defaultLocale\n  );\n};\n"],"mappings":"yNAkCA,MAAa,EAAW,GAAwC,CAC9D,IAAM,EAAgB,EAAgC,EAAsB,CAE5E,OAAO,EACL,GACE,GACA,GAAe,sBAAsB,cACxC"}
+{"version":3,"file":"useIntl.mjs","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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): WrappedIntl => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return bindIntl(\n    locale ??\n      currentLocale ??\n      configuration?.internationalization?.defaultLocale\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,WAAW,WAAwC;CAC9D,MAAM,gBAAgB,iBAAgC,sBAAsB;AAE5E,QAAO,SACL,UACE,iBACA,eAAe,sBAAsB,cACxC"}

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

@@ -1,2 +1,34 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{list as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as useList};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { list } from "@intlayer/core/formatters";
+
+//#region src/server/format/useList.ts
+/**
+* React server hook that provides a list formatter
+* bound to the current application locale.
+*
+* @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 = getServerContext(IntlayerServerContext);
+	return (...args) => list(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useList };
 //# sourceMappingURL=useList.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useList.mjs","names":[],"sources":["../../../../src/server/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React server hook that provides a list formatter\n * bound to the current application locale.\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":"+KAuBA,MAAa,MAAgB,CAC3B,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAK,EAAK,GAAI,CACZ,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useList.mjs","names":[],"sources":["../../../../src/server/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\n\n/**\n * React server hook that provides a list formatter\n * bound to the current application locale.\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,KAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

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

@@ -1,2 +1,38 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{number as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as useNumber};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { number } from "@intlayer/core/formatters";
+
+//#region src/server/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 = getServerContext(IntlayerServerContext);
+	return (...args) => number(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useNumber };
 //# sourceMappingURL=useNumber.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useNumber.mjs","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":"iLA2BA,MAAa,MAAkB,CAC7B,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAO,EAAK,GAAI,CACd,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useNumber.mjs","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,kBAAkB;CAC7B,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,OAAO,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

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

@@ -1,2 +1,34 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{percentage as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as usePercentage};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { percentage } from "@intlayer/core/formatters";
+
+//#region src/server/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 = getServerContext(IntlayerServerContext);
+	return (...args) => percentage(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { usePercentage };
 //# sourceMappingURL=usePercentage.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.mjs","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":"qLAuBA,MAAa,MAAsB,CACjC,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAW,EAAK,GAAI,CAClB,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"usePercentage.mjs","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,sBAAsB;CACjC,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,WAAW,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

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

@@ -1,2 +1,34 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{relativeTime as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],e[1]??new Date,{...e[2],locale:e[2]?.locale??r})};export{r as useRelativeTime};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { relativeTime } from "@intlayer/core/formatters";
+
+//#region src/server/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 = getServerContext(IntlayerServerContext);
+	return (...args) => relativeTime(args[0], args[1] ?? /* @__PURE__ */ new Date(), {
+		...args[2],
+		locale: args[2]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.mjs","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1] ?? new Date(), {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":"uLAuBA,MAAa,MAAwB,CACnC,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAa,EAAK,GAAI,EAAK,IAAM,IAAI,KAAQ,CAC3C,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useRelativeTime.mjs","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1] ?? new Date(), {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,wBAAwB;CACnC,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,aAAa,KAAK,IAAI,KAAK,sBAAM,IAAI,MAAM,EAAE;EAC3C,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

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

@@ -1,2 +1,33 @@
-import{getServerContext as e}from"../serverContext.mjs";import{IntlayerServerContext as t}from"../IntlayerServerProvider.mjs";import{units as n}from"@intlayer/core/formatters";const r=()=>{let r=e(t);return(...e)=>n(e[0],{...e[1],locale:e[1]?.locale??r})};export{r as useUnit};
+import { getServerContext } from "../serverContext.mjs";
+import { IntlayerServerContext } from "../IntlayerServerProvider.mjs";
+import { units } from "@intlayer/core/formatters";
+
+//#region src/server/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 = getServerContext(IntlayerServerContext);
+	return (...args) => units(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useUnit };
 //# sourceMappingURL=useUnit.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useUnit.mjs","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":"gLAsBA,MAAa,MAAgB,CAC3B,IAAM,EAAS,EAAgC,EAAsB,CAErE,OAAQ,GAAG,IACT,EAAM,EAAK,GAAI,CACb,GAAG,EAAK,GACR,OAAQ,EAAK,IAAI,QAAU,EAC5B,CAAC"}
+{"version":3,"file":"useUnit.mjs","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from '../IntlayerServerProvider';\nimport { getServerContext } from '../serverContext';\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 = getServerContext<LocalesValues>(IntlayerServerContext);\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAgC,sBAAsB;AAErE,SAAQ,GAAG,SACT,MAAM,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,IAAI,UAAU;EAC5B,CAAC"}

package/dist/esm/server/index.mjs

@@ -1 +1,12 @@
-import{IntlayerServerContext as e,IntlayerServerProvider as t,locale as n}from"./IntlayerServerProvider.mjs";import{t as r}from"./t.mjs";import{useI18n as i}from"./useI18n.mjs";import{useIntlayer as a}from"./useIntlayer.mjs";import{useDictionary as o}from"./useDictionary.mjs";import{useDictionaryAsync as s}from"./useDictionaryAsync.mjs";import{useLocale as c}from"./useLocale.mjs";import{useLoadDynamic as l}from"./useLoadDynamic.mjs";import{useDictionaryDynamic as u}from"./useDictionaryDynamic.mjs";import{useIntl as d}from"./format/useIntl.mjs";export{e as IntlayerServer,t as IntlayerServerProvider,n as locale,r as t,o as useDictionary,s as useDictionaryAsync,u as useDictionaryDynamic,i as useI18n,d as useIntl,a as useIntlayer,l as useLoadDynamic,c as useLocale};
+import { IntlayerServerContext, IntlayerServerProvider, locale } from "./IntlayerServerProvider.mjs";
+import { t } from "./t.mjs";
+import { useI18n } from "./useI18n.mjs";
+import { useIntlayer } from "./useIntlayer.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useDictionaryAsync } from "./useDictionaryAsync.mjs";
+import { useLocale } from "./useLocale.mjs";
+import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.mjs";
+import { useIntl } from "./format/useIntl.mjs";
+
+export { IntlayerServerContext as IntlayerServer, IntlayerServerProvider, locale, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale };

package/dist/esm/server/serverContext.mjs

@@ -1,2 +1,55 @@
-import e from"react";const t=()=>()=>({value:void 0}),n=n=>{i();let r=(e.cache??t)(()=>({value:void 0})),a=({children:e,value:t})=>(r().value=t,e),o=a;return o.Provider=a,o.Consumer=e=>{let t=r();return e.children(t?t.value:n)},o._storage=r,o._defaultValue=n,o},r=({_storage:e,_defaultValue:t})=>{let n=e();return n?n.value:t},i=()=>{if(typeof window<`u`)throw Error(`createServerContext only works in Server Components`)};export{n as createServerContext,r as getServerContext};
+import react from "react";
+
+//#region src/server/serverContext.tsx
+/**
+* Creates a new datastore for a given server context.
+* Attempts to closely mimic the `createContext` API.
+*
+* @example
+* const IntlayerServer = createServerContext<string | null>(null);
+*
+* <IntlayerServer value={locale}>
+*      {children}
+* </IntlayerServer>
+*/
+const cacheFallback = () => () => ({ value: void 0 });
+const createServerContext = (defaultValue) => {
+	throwInClient();
+	const getCache = (react.cache ?? cacheFallback)(() => ({ value: void 0 }));
+	const Provider = ({ children, value }) => {
+		getCache().value = value;
+		return children;
+	};
+	const ServerContext = Provider;
+	ServerContext.Provider = Provider;
+	ServerContext.Consumer = (props) => {
+		const store = getCache();
+		return props.children(store ? store.value : defaultValue);
+	};
+	ServerContext._storage = getCache;
+	ServerContext._defaultValue = defaultValue;
+	return ServerContext;
+};
+/**
+* Fetches a value present in a given server context.
+* Attempts to closely mimic the `useContext` API.
+*
+* @example
+* getServerContext(IntlayerServer);
+*/
+const getServerContext = ({ _storage, _defaultValue }) => {
+	const store = _storage();
+	if (!store) return _defaultValue;
+	return store.value;
+};
+/**
+* Throws if called within a client component environment.
+* Useful to help prevent mistakes.
+*/
+const throwInClient = () => {
+	if (typeof window !== "undefined") throw new Error(`createServerContext only works in Server Components`);
+};
+
+//#endregion
+export { createServerContext, getServerContext };
 //# sourceMappingURL=serverContext.mjs.map

package/dist/esm/server/serverContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"serverContext.mjs","names":[],"sources":["../../../src/server/serverContext.tsx"],"sourcesContent":["/**\n * Creates a new datastore for a given server context.\n * Attempts to closely mimic the `createContext` API.\n *\n * @example\n * const IntlayerServer = createServerContext<string | null>(null);\n *\n * <IntlayerServer value={locale}>\n *      {children}\n * </IntlayerServer>\n */\nimport react, { type FC, type PropsWithChildren, type ReactNode } from 'react';\n\ntype CacheType<T> = () => { value: T | undefined };\n\nconst cacheFallback = () => () => ({ value: undefined });\n\nexport const createServerContext = <T,>(defaultValue?: T): ServerContext<T> => {\n  throwInClient();\n\n  /** @ts-ignore remove error Property 'cache' does not exist on type 'typeof React'. */\n  const cache = react.cache<CacheType<T>> ?? cacheFallback;\n\n  const getCache = cache(() => ({\n    value: undefined,\n  }));\n\n  const Provider: FC<PropsWithChildren<{ value?: T }>> = ({\n    children,\n    value,\n  }) => {\n    getCache().value = value;\n    return children;\n  };\n\n  const ServerContext = Provider as ServerContext<T>;\n  ServerContext.Provider = Provider;\n  ServerContext.Consumer = (props) => {\n    const store = getCache();\n    return props.children(store ? store.value : defaultValue);\n  };\n  ServerContext._storage = getCache;\n  ServerContext._defaultValue = defaultValue;\n\n  return ServerContext;\n};\n\n/**\n * Fetches a value present in a given server context.\n * Attempts to closely mimic the `useContext` API.\n *\n * @example\n * getServerContext(IntlayerServer);\n */\nexport const getServerContext = <T,>({\n  _storage,\n  _defaultValue,\n}: ServerContext<T>) => {\n  // throwInClient();\n  const store = _storage();\n  if (!store) return _defaultValue;\n  return store.value;\n};\n\ntype ServerContext<T> = FC<PropsWithChildren<{ value?: T }>> & {\n  Provider: FC<PropsWithChildren<{ value?: T }>>;\n  Consumer: FC<\n    PropsWithChildren<{ children: (context: T | undefined) => ReactNode }>\n  >;\n  _storage: () => { value: T | undefined };\n  _defaultValue: T | undefined;\n};\n\n/**\n * Throws if called within a client component environment.\n * Useful to help prevent mistakes.\n */\nconst throwInClient = (): undefined | never => {\n  // If window.document is defined we're in a client component\n  if (typeof window !== 'undefined') {\n    throw new Error(`createServerContext only works in Server Components`);\n  }\n};\n"],"mappings":"qBAeA,MAAM,WAA6B,CAAE,MAAO,IAAA,GAAW,EAE1C,EAA2B,GAAuC,CAC7E,GAAe,CAKf,IAAM,GAFQ,EAAM,OAAuB,QAEb,CAC5B,MAAO,IAAA,GACR,EAAE,CAEG,GAAkD,CACtD,WACA,YAEA,GAAU,CAAC,MAAQ,EACZ,GAGH,EAAgB,EAStB,MARA,GAAc,SAAW,EACzB,EAAc,SAAY,GAAU,CAClC,IAAM,EAAQ,GAAU,CACxB,OAAO,EAAM,SAAS,EAAQ,EAAM,MAAQ,EAAa,EAE3D,EAAc,SAAW,EACzB,EAAc,cAAgB,EAEvB,GAUI,GAAwB,CACnC,WACA,mBACsB,CAEtB,IAAM,EAAQ,GAAU,CAExB,OADK,EACE,EAAM,MADM,GAiBf,MAAyC,CAE7C,GAAI,OAAO,OAAW,IACpB,MAAU,MAAM,sDAAsD"}
+{"version":3,"file":"serverContext.mjs","names":[],"sources":["../../../src/server/serverContext.tsx"],"sourcesContent":["/**\n * Creates a new datastore for a given server context.\n * Attempts to closely mimic the `createContext` API.\n *\n * @example\n * const IntlayerServer = createServerContext<string | null>(null);\n *\n * <IntlayerServer value={locale}>\n *      {children}\n * </IntlayerServer>\n */\nimport react, { type FC, type PropsWithChildren, type ReactNode } from 'react';\n\ntype CacheType<T> = () => { value: T | undefined };\n\nconst cacheFallback = () => () => ({ value: undefined });\n\nexport const createServerContext = <T,>(defaultValue?: T): ServerContext<T> => {\n  throwInClient();\n\n  /** @ts-ignore remove error Property 'cache' does not exist on type 'typeof React'. */\n  const cache = react.cache<CacheType<T>> ?? cacheFallback;\n\n  const getCache = cache(() => ({\n    value: undefined,\n  }));\n\n  const Provider: FC<PropsWithChildren<{ value?: T }>> = ({\n    children,\n    value,\n  }) => {\n    getCache().value = value;\n    return children;\n  };\n\n  const ServerContext = Provider as ServerContext<T>;\n  ServerContext.Provider = Provider;\n  ServerContext.Consumer = (props) => {\n    const store = getCache();\n    return props.children(store ? store.value : defaultValue);\n  };\n  ServerContext._storage = getCache;\n  ServerContext._defaultValue = defaultValue;\n\n  return ServerContext;\n};\n\n/**\n * Fetches a value present in a given server context.\n * Attempts to closely mimic the `useContext` API.\n *\n * @example\n * getServerContext(IntlayerServer);\n */\nexport const getServerContext = <T,>({\n  _storage,\n  _defaultValue,\n}: ServerContext<T>) => {\n  // throwInClient();\n  const store = _storage();\n  if (!store) return _defaultValue;\n  return store.value;\n};\n\ntype ServerContext<T> = FC<PropsWithChildren<{ value?: T }>> & {\n  Provider: FC<PropsWithChildren<{ value?: T }>>;\n  Consumer: FC<\n    PropsWithChildren<{ children: (context: T | undefined) => ReactNode }>\n  >;\n  _storage: () => { value: T | undefined };\n  _defaultValue: T | undefined;\n};\n\n/**\n * Throws if called within a client component environment.\n * Useful to help prevent mistakes.\n */\nconst throwInClient = (): undefined | never => {\n  // If window.document is defined we're in a client component\n  if (typeof window !== 'undefined') {\n    throw new Error(`createServerContext only works in Server Components`);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAM,6BAA6B,EAAE,OAAO,QAAW;AAEvD,MAAa,uBAA2B,iBAAuC;AAC7E,gBAAe;CAKf,MAAM,YAFQ,MAAM,SAAuB,sBAEb,EAC5B,OAAO,QACR,EAAE;CAEH,MAAM,YAAkD,EACtD,UACA,YACI;AACJ,YAAU,CAAC,QAAQ;AACnB,SAAO;;CAGT,MAAM,gBAAgB;AACtB,eAAc,WAAW;AACzB,eAAc,YAAY,UAAU;EAClC,MAAM,QAAQ,UAAU;AACxB,SAAO,MAAM,SAAS,QAAQ,MAAM,QAAQ,aAAa;;AAE3D,eAAc,WAAW;AACzB,eAAc,gBAAgB;AAE9B,QAAO;;;;;;;;;AAUT,MAAa,oBAAwB,EACnC,UACA,oBACsB;CAEtB,MAAM,QAAQ,UAAU;AACxB,KAAI,CAAC,MAAO,QAAO;AACnB,QAAO,MAAM;;;;;;AAgBf,MAAM,sBAAyC;AAE7C,KAAI,OAAO,WAAW,YACpB,OAAM,IAAI,MAAM,sDAAsD"}

package/dist/esm/server/t.mjs

@@ -1,2 +1,34 @@
-import{getServerContext as e}from"./serverContext.mjs";import{IntlayerServerContext as t}from"./IntlayerServerProvider.mjs";import{getTranslation as n}from"@intlayer/core/interpreter";const r=(r,i)=>{let a=e(t);return n(r,i??a)};export{r as t};
+import { getServerContext } from "./serverContext.mjs";
+import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
+import { getTranslation } from "@intlayer/core/interpreter";
+
+//#region src/server/t.ts
+/**
+* On the server side, hook to get the translation content based on the locale
+*
+* If not locale found, it will return the content related to the default locale.
+*
+* Return either the content editor, or the content itself depending on the configuration.
+*
+* Usage:
+*
+* ```ts
+* const content = t<string>({
+*   en: 'Hello',
+*   fr: 'Bonjour',
+* }, 'fr');
+* // 'Bonjour'
+* ```
+*
+* Using TypeScript:
+* - this function will require each locale to be defined if defined in the project configuration.
+* - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+*/
+const t = (multilangContent, locale) => {
+	const currentLocale = getServerContext(IntlayerServerContext);
+	return getTranslation(multilangContent, locale ?? currentLocale);
+};
+
+//#endregion
+export { t };
 //# sourceMappingURL=t.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.mjs","names":[],"sources":["../../../src/server/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, hook to get the translation content based on the locale\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 * ```ts\n * const content = t<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 t = <Content = string, L extends LocalesValues = DeclaredLocales>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: L\n) => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n  const localeTarget = locale ?? (currentLocale as LocalesValues);\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":"wLA0BA,MAAa,GACX,EACA,IACG,CACH,IAAM,EAAgB,EAAgC,EAAsB,CAG5E,OAAO,EAAwB,EAFV,GAAW,EAE8B"}
+{"version":3,"file":"t.mjs","names":[],"sources":["../../../src/server/t.ts"],"sourcesContent":["import { getTranslation } from '@intlayer/core/interpreter';\nimport type { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\n\n/**\n * On the server side, hook to get the translation content based on the locale\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 * ```ts\n * const content = t<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 t = <Content = string, L extends LocalesValues = DeclaredLocales>(\n  multilangContent: StrictModeLocaleMap<Content>,\n  locale?: L\n) => {\n  const currentLocale = getServerContext<LocalesValues>(IntlayerServerContext);\n  const localeTarget = locale ?? (currentLocale as LocalesValues);\n\n  return getTranslation<Content>(multilangContent, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,KACX,kBACA,WACG;CACH,MAAM,gBAAgB,iBAAgC,sBAAsB;AAG5E,QAAO,eAAwB,kBAFV,UAAW,cAE8B"}

package/dist/esm/server/useDictionary.mjs

@@ -1,2 +1,17 @@
-import{getDictionary as e}from"../getDictionary.mjs";import{getServerContext as t}from"./serverContext.mjs";import{IntlayerServerContext as n}from"./IntlayerServerProvider.mjs";const r=(r,i,a)=>e(r,i??t(n)??a);export{r as useDictionary};
+import { getDictionary } from "../getDictionary.mjs";
+import { getServerContext } from "./serverContext.mjs";
+import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
+
+//#region src/server/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 server context
+*/
+const useDictionary = (dictionary, locale, fallbackLocale) => {
+	return getDictionary(dictionary, locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale);
+};
+
+//#endregion
+export { useDictionary };
 //# sourceMappingURL=useDictionary.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":"iLAcA,MAAa,GAIX,EACA,EACA,IAOO,EAAoB,EAJzB,GACA,EAAgC,EAAsB,EACtD,EAEuD"}
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale;\n\n  return getDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAa,iBAIX,YACA,QACA,mBACG;AAMH,QAAO,cAAoB,YAJzB,UACA,iBAAgC,sBAAsB,IACtD,eAEuD"}

package/dist/esm/server/useDictionaryAsync.mjs

@@ -1,2 +1,19 @@
-import{getServerContext as e}from"./serverContext.mjs";import{IntlayerServerContext as t}from"./IntlayerServerProvider.mjs";import{useDictionary as n}from"./useDictionary.mjs";import r from"@intlayer/config/built";const i=async(i,a,o)=>{let s=a??e(t)??o??r?.internationalization.defaultLocale;return n(await i[s]?.(),s)};export{i as useDictionaryAsync};
+import { getServerContext } from "./serverContext.mjs";
+import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import configuration from "@intlayer/config/built";
+
+//#region src/server/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 server context
+*/
+const useDictionaryAsync = async (dictionaryPromise, locale, fallbackLocale) => {
+	const localeTarget = locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale ?? configuration?.internationalization.defaultLocale;
+	return useDictionary(await dictionaryPromise[localeTarget]?.(), localeTarget);
+};
+
+//#endregion
+export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import 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 { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server 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  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    configuration?.internationalization.defaultLocale;\n\n  const dictionary = await (dictionaryPromise as any)[localeTarget]?.();\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":"sNAgBA,MAAa,EAAqB,MAIhC,EACA,EACA,IACG,CACH,IAAM,EACJ,GACA,EAAgC,EAAsB,EACtD,GACA,GAAe,qBAAqB,cAItC,OAAO,EAFY,MAAO,EAA0B,MAAiB,CAE9B,EAAkB"}
+{"version":3,"file":"useDictionaryAsync.mjs","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import 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 { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server 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  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    configuration?.internationalization.defaultLocale;\n\n  const dictionary = await (dictionaryPromise as any)[localeTarget]?.();\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;AAgBA,MAAa,qBAAqB,OAIhC,mBACA,QACA,mBACG;CACH,MAAM,eACJ,UACA,iBAAgC,sBAAsB,IACtD,kBACA,eAAe,qBAAqB;AAItC,QAAO,cAFY,MAAO,kBAA0B,iBAAiB,EAE9B,aAAkB"}

package/dist/esm/server/useDictionaryDynamic.mjs

@@ -1,2 +1,20 @@
-import{getServerContext as e}from"./serverContext.mjs";import{IntlayerServerContext as t}from"./IntlayerServerProvider.mjs";import{useDictionary as n}from"./useDictionary.mjs";import{useLoadDynamic as r}from"./useLoadDynamic.mjs";import i from"@intlayer/config/built";const a=(a,o,s,c)=>{let l=s??e(t)??c??i?.internationalization.defaultLocale;return n(r(`${String(o)}.${l}`,a[l]?.()),l)};export{a as useDictionaryDynamic};
+import { getServerContext } from "./serverContext.mjs";
+import { IntlayerServerContext } from "./IntlayerServerProvider.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useLoadDynamic } from "./useLoadDynamic.mjs";
+import configuration from "@intlayer/config/built";
+
+//#region src/server/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 server context
+*/
+const useDictionaryDynamic = (dictionaryPromise, key, locale, fallbackLocale) => {
+	const localeTarget = locale ?? getServerContext(IntlayerServerContext) ?? fallbackLocale ?? configuration?.internationalization.defaultLocale;
+	return useDictionary(useLoadDynamic(`${String(key)}.${localeTarget}`, dictionaryPromise[localeTarget]?.()), localeTarget);
+};
+
+//#endregion
+export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import 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 { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    configuration?.internationalization.defaultLocale;\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":"4QAiBA,MAAa,GAIX,EACA,EACA,EACA,IACG,CACH,IAAM,EACJ,GACA,EAAgC,EAAsB,EACtD,GACA,GAAe,qBAAqB,cAOtC,OAAO,EALY,EACjB,GAAG,OAAO,EAAI,CAAC,GAAG,IACjB,EAA0B,MAAiB,CAC7C,CAEsC,EAAkB"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import 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 { IntlayerServerContext } from './IntlayerServerProvider';\nimport { getServerContext } from './serverContext';\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 server context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\n  locale?: L,\n  fallbackLocale?: DeclaredLocales\n) => {\n  const localeTarget =\n    locale ??\n    getServerContext<LocalesValues>(IntlayerServerContext) ??\n    fallbackLocale ??\n    configuration?.internationalization.defaultLocale;\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget}`,\n    (dictionaryPromise as any)[localeTarget]?.()\n  );\n\n  return useDictionary<T, L>(dictionary, localeTarget as L);\n};\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAa,wBAIX,mBACA,KACA,QACA,mBACG;CACH,MAAM,eACJ,UACA,iBAAgC,sBAAsB,IACtD,kBACA,eAAe,qBAAqB;AAOtC,QAAO,cALY,eACjB,GAAG,OAAO,IAAI,CAAC,GAAG,gBACjB,kBAA0B,iBAAiB,CAC7C,EAEsC,aAAkB"}