react-intlayer 1.0.1 → 1.2.1

package/dist/cjs/{LocaleContextProvider.cjs → IntlayerProvider.cjs}

@@ -16,22 +16,22 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var LocaleContextProvider_exports = {};
-__export(LocaleContextProvider_exports, {
-  LocaleContextProvider: () => LocaleContextProvider
+var IntlayerProvider_exports = {};
+__export(IntlayerProvider_exports, {
+  IntlayerProvider: () => IntlayerProvider
 });
-module.exports = __toCommonJS(LocaleContextProvider_exports);
+module.exports = __toCommonJS(IntlayerProvider_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_client = require("@intlayer/config/client");
-var import_LocaleClientContextProvider = require('./client/LocaleClientContextProvider.cjs');
-var import_LocaleServerContextProvider = require('./server/LocaleServerContextProvider.cjs');
-const defaultLocale = import_client.intlayerIntlConfiguration.defaultLocale;
-const LocaleContextProvider = ({
+var import_IntlayerClientProvider = require('./client/IntlayerClientProvider.cjs');
+var import_IntlayerServerProvider = require('./server/IntlayerServerProvider.cjs');
+const { defaultLocale } = (0, import_client.getConfiguration)().internationalization;
+const IntlayerProvider = ({
   children,
   locale = defaultLocale
-}) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_LocaleServerContextProvider.LocaleServerContextProvider, { locale, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_LocaleClientContextProvider.LocaleClientContextProvider, { locale, children }) });
+}) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_IntlayerServerProvider.IntlayerServerProvider, { locale, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_IntlayerClientProvider.IntlayerClientProvider, { locale, children }) });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LocaleContextProvider
+  IntlayerProvider
 });
-//# sourceMappingURL=LocaleContextProvider.cjs.map
+//# sourceMappingURL=IntlayerProvider.cjs.map

package/dist/cjs/IntlayerProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/IntlayerProvider.tsx"],"sourcesContent":["import { getConfiguration } from '@intlayer/config/client';\nimport type { FC } from 'react';\nimport {\n  IntlayerClientProvider,\n  type IntlayerClientProviderProps,\n} from './client/IntlayerClientProvider';\nimport {\n  IntlayerServerProvider,\n  type IntlayerServerProviderProps,\n} from './server/IntlayerServerProvider';\n\nconst { defaultLocale } = getConfiguration().internationalization;\n\ntype IntlayerProviderProps = IntlayerClientProviderProps &\n  IntlayerServerProviderProps;\n\nexport const IntlayerProvider: FC<IntlayerProviderProps> = ({\n  children,\n  locale = defaultLocale,\n}) => (\n  <IntlayerServerProvider locale={locale}>\n    <IntlayerClientProvider locale={locale}>{children}</IntlayerClientProvider>\n  </IntlayerServerProvider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBI;AArBJ,oBAAiC;AAEjC,oCAGO;AACP,oCAGO;AAEP,MAAM,EAAE,cAAc,QAAI,gCAAiB,EAAE;AAKtC,MAAM,mBAA8C,CAAC;AAAA,EAC1D;AAAA,EACA,SAAS;AACX,MACE,4CAAC,wDAAuB,QACtB,sDAAC,wDAAuB,QAAiB,UAAS,GACpD;","names":[]}

package/dist/cjs/IntlayerProvider.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { IntlayerClientProviderProps } from './client/IntlayerClientProvider.js';
+import { IntlayerServerProviderProps } from './server/IntlayerServerProvider.js';
+import '@intlayer/config/client';
+
+type IntlayerProviderProps = IntlayerClientProviderProps & IntlayerServerProviderProps;
+declare const IntlayerProvider: FC<IntlayerProviderProps>;
+
+export { IntlayerProvider };

package/dist/cjs/cli/react-intlayer.cjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_cross_spawn = __toESM(require("cross-spawn"));
+const args = process.argv.slice(2);
+const scriptIndex = args.findIndex(
+  (x) => x === "build" || x === "start" || x === "test"
+);
+const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
+switch (script) {
+  case "build":
+  case "start":
+  case "test": {
+    const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
+    const scriptPath = require.resolve(`@craco/craco/dist/scripts/${script}`);
+    const scriptArgs = args.slice(scriptIndex + 1);
+    const processArgs = nodeArgs.concat(scriptPath).concat([
+      ...scriptArgs,
+      "--config",
+      "./node_modules/react-intlayer/dist/cjs/craco/craco.config.cjs"
+    ]);
+    const child = import_cross_spawn.default.sync("node", processArgs, { stdio: "inherit" });
+    if (child.signal) {
+      if (child.signal === "SIGKILL") {
+        console.info(`
+                The build failed because the process exited too early.
+                This probably means the system ran out of memory or someone called
+                \`kill -9\` on the process.
+            `);
+      } else if (child.signal === "SIGTERM") {
+        console.info(`
+                The build failed because the process exited too early.
+                Someone might have called  \`kill\` or \`killall\`, or the system could
+                be shutting down.
+            `);
+      }
+      process.exit(1);
+    }
+    process.exit(child.status ?? void 0);
+    break;
+  }
+  default:
+    console.info(`Unknown script "${script}".`);
+    console.info("Perhaps you need to update craco?");
+    break;
+}
+//# sourceMappingURL=react-intlayer.cjs.map

package/dist/cjs/cli/react-intlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/react-intlayer.ts"],"sourcesContent":["#!/usr/bin/env node\n\n/**\n * To make the setup easier, we are using craco to override the webpack configuration.\n * This script is used to run the craco scripts with the custom configuration.\n *\n * The script is based on the original craco script from create-react-app.\n */\n\nimport spawn from 'cross-spawn';\n\nconst args = process.argv.slice(2);\nconst scriptIndex = args.findIndex(\n  (x) => x === 'build' || x === 'start' || x === 'test'\n);\nconst script = scriptIndex === -1 ? args[0] : args[scriptIndex];\n\nswitch (script) {\n  case 'build':\n  case 'start':\n  case 'test': {\n    const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];\n    const scriptPath = require.resolve(`@craco/craco/dist/scripts/${script}`);\n    const scriptArgs = args.slice(scriptIndex + 1);\n    const processArgs = nodeArgs\n      .concat(scriptPath)\n      .concat([\n        ...scriptArgs,\n        '--config',\n        './node_modules/react-intlayer/dist/cjs/craco/craco.config.cjs',\n      ]);\n\n    const child = spawn.sync('node', processArgs, { stdio: 'inherit' });\n\n    if (child.signal) {\n      if (child.signal === 'SIGKILL') {\n        console.info(`\n                The build failed because the process exited too early.\n                This probably means the system ran out of memory or someone called\n                \\`kill -9\\` on the process.\n            `);\n      } else if (child.signal === 'SIGTERM') {\n        console.info(`\n                The build failed because the process exited too early.\n                Someone might have called  \\`kill\\` or \\`killall\\`, or the system could\n                be shutting down.\n            `);\n      }\n\n      process.exit(1);\n    }\n\n    process.exit(child.status ?? undefined);\n    break;\n  }\n  default:\n    console.info(`Unknown script \"${script}\".`);\n    console.info('Perhaps you need to update craco?');\n    break;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AASA,yBAAkB;AAElB,MAAM,OAAO,QAAQ,KAAK,MAAM,CAAC;AACjC,MAAM,cAAc,KAAK;AAAA,EACvB,CAAC,MAAM,MAAM,WAAW,MAAM,WAAW,MAAM;AACjD;AACA,MAAM,SAAS,gBAAgB,KAAK,KAAK,CAAC,IAAI,KAAK,WAAW;AAE9D,QAAQ,QAAQ;AAAA,EACd,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK,QAAQ;AACX,UAAM,WAAW,cAAc,IAAI,KAAK,MAAM,GAAG,WAAW,IAAI,CAAC;AACjE,UAAM,aAAa,QAAQ,QAAQ,6BAA6B,MAAM,EAAE;AACxE,UAAM,aAAa,KAAK,MAAM,cAAc,CAAC;AAC7C,UAAM,cAAc,SACjB,OAAO,UAAU,EACjB,OAAO;AAAA,MACN,GAAG;AAAA,MACH;AAAA,MACA;AAAA,IACF,CAAC;AAEH,UAAM,QAAQ,mBAAAA,QAAM,KAAK,QAAQ,aAAa,EAAE,OAAO,UAAU,CAAC;AAElE,QAAI,MAAM,QAAQ;AAChB,UAAI,MAAM,WAAW,WAAW;AAC9B,gBAAQ,KAAK;AAAA;AAAA;AAAA;AAAA,aAIR;AAAA,MACP,WAAW,MAAM,WAAW,WAAW;AACrC,gBAAQ,KAAK;AAAA;AAAA;AAAA;AAAA,aAIR;AAAA,MACP;AAEA,cAAQ,KAAK,CAAC;AAAA,IAChB;AAEA,YAAQ,KAAK,MAAM,UAAU,MAAS;AACtC;AAAA,EACF;AAAA,EACA;AACE,YAAQ,KAAK,mBAAmB,MAAM,IAAI;AAC1C,YAAQ,KAAK,mCAAmC;AAChD;AACJ;","names":["spawn"]}

package/dist/cjs/cli/react-intlayer.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cjs/client/IntlayerClientProvider.cjs

@@ -0,0 +1,69 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IntlayerClientProvider_exports = {};
+__export(IntlayerClientProvider_exports, {
+  IntlayerClientContext: () => IntlayerClientContext,
+  IntlayerClientProvider: () => IntlayerClientProvider,
+  useIntlayerContext: () => useIntlayerContext
+});
+module.exports = __toCommonJS(IntlayerClientProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = require("@intlayer/config/client");
+var import_react = require("react");
+var import_useLocaleCookie = require('./useLocaleCookie.cjs');
+const IntlayerClientContext = (0, import_react.createContext)({
+  locale: import_useLocaleCookie.localeCookie ?? (0, import_client.getConfiguration)().internationalization.defaultLocale,
+  setLocale: () => null
+});
+const useIntlayerContext = () => (0, import_react.useContext)(IntlayerClientContext);
+const IntlayerClientProvider = ({
+  locale,
+  children
+}) => {
+  const { defaultLocale, locales: availableLocales } = (0, import_client.getConfiguration)().internationalization;
+  const [currentLocale, setCurrentLocale] = (0, import_react.useState)(
+    locale ?? import_useLocaleCookie.localeCookie ?? defaultLocale
+  );
+  const setLocale = (0, import_react.useCallback)(
+    (newLocale) => {
+      if (currentLocale.toString() === newLocale.toString())
+        return;
+      if (!availableLocales.includes(newLocale)) {
+        console.error(`Locale ${locale} is not available`);
+        return;
+      }
+      setCurrentLocale(newLocale);
+      (0, import_useLocaleCookie.setLocaleCookie)(newLocale);
+    },
+    [availableLocales, currentLocale, locale]
+  );
+  const value = (0, import_react.useMemo)(
+    () => ({ locale: currentLocale, setLocale }),
+    [currentLocale, setLocale]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(IntlayerClientContext.Provider, { value, children });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntlayerClientContext,
+  IntlayerClientProvider,
+  useIntlayerContext
+});
+//# sourceMappingURL=IntlayerClientProvider.cjs.map

package/dist/cjs/client/IntlayerClientProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/IntlayerClientProvider.tsx"],"sourcesContent":["'use client';\n\nimport { getConfiguration, type Locales } from '@intlayer/config/client';\nimport {\n  type PropsWithChildren,\n  createContext,\n  useContext,\n  useMemo,\n  type FC,\n  useState,\n  useCallback,\n} from 'react';\nimport { localeCookie, setLocaleCookie } from './useLocaleCookie';\n\ntype IntlayerValue = {\n  locale: Locales;\n  setLocale: (newLocale: Locales) => void;\n};\n\n/**\n * Context that store the current locale on the client side\n */\nexport const IntlayerClientContext = createContext<IntlayerValue>({\n  locale: localeCookie ?? getConfiguration().internationalization.defaultLocale,\n  setLocale: () => null,\n});\n\n/**\n * Hook that provides the current locale\n */\nexport const useIntlayerContext = () => useContext(IntlayerClientContext);\n\nexport type IntlayerClientProviderProps = PropsWithChildren & {\n  locale?: Locales;\n};\n\n/**\n * Provider that store the current locale on the client side\n */\nexport const IntlayerClientProvider: FC<IntlayerClientProviderProps> = ({\n  locale,\n  children,\n}) => {\n  const { defaultLocale, locales: availableLocales } =\n    getConfiguration().internationalization;\n\n  const [currentLocale, setCurrentLocale] = useState(\n    locale ?? localeCookie ?? defaultLocale\n  );\n\n  const setLocale = useCallback(\n    (newLocale: Locales) => {\n      if (currentLocale.toString() === newLocale.toString()) return;\n\n      if (!availableLocales.includes(newLocale)) {\n        console.error(`Locale ${locale} is not available`);\n        return;\n      }\n\n      setCurrentLocale(newLocale); // Update state\n      setLocaleCookie(newLocale); // Optionally set cookie for persistence\n    },\n    [availableLocales, currentLocale, locale]\n  );\n\n  const value: IntlayerValue = useMemo<IntlayerValue>(\n    () => ({ locale: currentLocale, setLocale }),\n    [currentLocale, setLocale]\n  );\n\n  return (\n    <IntlayerClientContext.Provider value={value}>\n      {children}\n    </IntlayerClientContext.Provider>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuEI;AArEJ,oBAA+C;AAC/C,mBAQO;AACP,6BAA8C;AAUvC,MAAM,4BAAwB,4BAA6B;AAAA,EAChE,QAAQ,2CAAgB,gCAAiB,EAAE,qBAAqB;AAAA,EAChE,WAAW,MAAM;AACnB,CAAC;AAKM,MAAM,qBAAqB,UAAM,yBAAW,qBAAqB;AASjE,MAAM,yBAA0D,CAAC;AAAA,EACtE;AAAA,EACA;AACF,MAAM;AACJ,QAAM,EAAE,eAAe,SAAS,iBAAiB,QAC/C,gCAAiB,EAAE;AAErB,QAAM,CAAC,eAAe,gBAAgB,QAAI;AAAA,IACxC,UAAU,uCAAgB;AAAA,EAC5B;AAEA,QAAM,gBAAY;AAAA,IAChB,CAAC,cAAuB;AACtB,UAAI,cAAc,SAAS,MAAM,UAAU,SAAS;AAAG;AAEvD,UAAI,CAAC,iBAAiB,SAAS,SAAS,GAAG;AACzC,gBAAQ,MAAM,UAAU,MAAM,mBAAmB;AACjD;AAAA,MACF;AAEA,uBAAiB,SAAS;AAC1B,kDAAgB,SAAS;AAAA,IAC3B;AAAA,IACA,CAAC,kBAAkB,eAAe,MAAM;AAAA,EAC1C;AAEA,QAAM,YAAuB;AAAA,IAC3B,OAAO,EAAE,QAAQ,eAAe,UAAU;AAAA,IAC1C,CAAC,eAAe,SAAS;AAAA,EAC3B;AAEA,SACE,4CAAC,sBAAsB,UAAtB,EAA+B,OAC7B,UACH;AAEJ;","names":[]}

package/dist/cjs/client/IntlayerClientProvider.d.ts

@@ -0,0 +1,25 @@
+import * as react from 'react';
+import { PropsWithChildren, FC } from 'react';
+import { Locales } from '@intlayer/config/client';
+
+type IntlayerValue = {
+    locale: Locales;
+    setLocale: (newLocale: Locales) => void;
+};
+/**
+ * Context that store the current locale on the client side
+ */
+declare const IntlayerClientContext: react.Context<IntlayerValue>;
+/**
+ * Hook that provides the current locale
+ */
+declare const useIntlayerContext: () => IntlayerValue;
+type IntlayerClientProviderProps = PropsWithChildren & {
+    locale?: Locales;
+};
+/**
+ * Provider that store the current locale on the client side
+ */
+declare const IntlayerClientProvider: FC<IntlayerClientProviderProps>;
+
+export { IntlayerClientContext, IntlayerClientProvider, type IntlayerClientProviderProps, useIntlayerContext };

package/dist/cjs/client/getBrowserLocale.cjs

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getBrowserLocale_exports = {};
+__export(getBrowserLocale_exports, {
+  LanguageDetector: () => LanguageDetector,
+  getBrowserLocale: () => getBrowserLocale
+});
+module.exports = __toCommonJS(getBrowserLocale_exports);
+var import_client = require("@intlayer/config/client");
+var import_core = require("@intlayer/core");
+var LanguageDetector = /* @__PURE__ */ ((LanguageDetector2) => {
+  LanguageDetector2["Querystring"] = "querystring";
+  LanguageDetector2["Cookie"] = "cookie";
+  LanguageDetector2["LocalStorage"] = "localStorage";
+  LanguageDetector2["SessionStorage"] = "sessionStorage";
+  LanguageDetector2["Navigator"] = "navigator";
+  LanguageDetector2["HtmlTag"] = "htmlTag";
+  return LanguageDetector2;
+})(LanguageDetector || {});
+const getDefaultsOptions = () => {
+  const { middleware } = (0, import_client.getConfiguration)();
+  return {
+    order: [
+      "querystring" /* Querystring */,
+      "cookie" /* Cookie */,
+      "navigator" /* Navigator */,
+      "htmlTag" /* HtmlTag */
+    ],
+    lookupQuerystring: "locale",
+    lookupCookie: middleware.cookieName,
+    htmlTag: document.documentElement
+  };
+};
+const isLocalStorageAvailable = () => {
+  try {
+    if (typeof window === "undefined")
+      return false;
+    const testKey = "intlayer.translate.boo";
+    window.localStorage.setItem(testKey, "foo");
+    window.localStorage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const isSessionStorageAvailable = () => {
+  try {
+    if (typeof window === "undefined")
+      return false;
+    const testKey = "intlayer.translate.boo";
+    window.sessionStorage.setItem(testKey, "foo");
+    window.sessionStorage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const detectLanguage = (order, options) => {
+  const detected = {};
+  const queryStringDetector = () => {
+    if (typeof window === "undefined")
+      return;
+    const search = window.location.search || "";
+    const params = new URLSearchParams(search);
+    const value = params.get(options.lookupQuerystring ?? "");
+    if (value) {
+      detected["querystring" /* Querystring */] = value;
+    }
+  };
+  const cookieDetector = () => {
+    if (typeof document === "undefined")
+      return;
+    const cookies = document.cookie.split(";");
+    const cookieName = `${options.lookupCookie ?? ""}=`;
+    const cookie = cookies.find((c) => c.trim().startsWith(cookieName));
+    if (cookie) {
+      const value = cookie.split("=")[1].trim();
+      detected["cookie" /* Cookie */] = value;
+    }
+  };
+  const localStorageDetector = () => {
+    if (!isLocalStorageAvailable())
+      return;
+    const value = window.localStorage.getItem(options.lookupLocalStorage ?? "");
+    if (value) {
+      detected["localStorage" /* LocalStorage */] = value;
+    }
+  };
+  const sessionStorageDetector = () => {
+    if (!isSessionStorageAvailable())
+      return;
+    const value = window.sessionStorage.getItem(
+      options.lookupSessionStorage ?? ""
+    );
+    if (value) {
+      detected["sessionStorage" /* SessionStorage */] = value;
+    }
+  };
+  const navigatorDetector = () => {
+    if (typeof navigator === "undefined")
+      return;
+    if (navigator.language) {
+      detected["navigator" /* Navigator */] = navigator.language;
+    }
+  };
+  const htmlTagDetector = () => {
+    const htmlTag = options.htmlTag;
+    if (htmlTag && typeof htmlTag.getAttribute === "function") {
+      const lang = htmlTag.getAttribute("lang");
+      if (lang) {
+        detected["htmlTag" /* HtmlTag */] = lang;
+      }
+    }
+  };
+  const detectors = {
+    ["querystring" /* Querystring */]: queryStringDetector,
+    ["cookie" /* Cookie */]: cookieDetector,
+    ["localStorage" /* LocalStorage */]: localStorageDetector,
+    ["sessionStorage" /* SessionStorage */]: sessionStorageDetector,
+    ["navigator" /* Navigator */]: navigatorDetector,
+    ["htmlTag" /* HtmlTag */]: htmlTagDetector
+  };
+  order.forEach((detectorName) => {
+    detectors[detectorName]?.();
+  });
+  return detected;
+};
+const getFirstAvailableLocale = (locales, order) => {
+  const { internationalization } = (0, import_client.getConfiguration)();
+  for (const detector of order) {
+    const localesArray = [locales[detector]].flat();
+    for (const locale of localesArray) {
+      if (locale && (internationalization.locales ?? import_core.localeList).includes(locale)) {
+        return locale;
+      } else if (locale?.includes("-") && (internationalization.locales ?? import_core.localeList).includes(
+        locale.split("-")[0]
+      )) {
+        return locale.split("-")[0];
+      }
+    }
+  }
+  return internationalization.defaultLocale;
+};
+const getBrowserLocale = (userOptions = {}) => {
+  const options = { ...getDefaultsOptions(), ...userOptions };
+  const locales = detectLanguage(options.order ?? [], options);
+  return getFirstAvailableLocale(locales, options.order ?? []);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LanguageDetector,
+  getBrowserLocale
+});
+//# sourceMappingURL=getBrowserLocale.cjs.map

package/dist/cjs/client/getBrowserLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/getBrowserLocale.tsx"],"sourcesContent":["import { getConfiguration, type Locales } from '@intlayer/config/client';\nimport { localeList } from '@intlayer/core';\n\nexport enum LanguageDetector {\n  Querystring = 'querystring',\n  Cookie = 'cookie',\n  LocalStorage = 'localStorage',\n  SessionStorage = 'sessionStorage',\n  Navigator = 'navigator',\n  HtmlTag = 'htmlTag',\n}\n\n// Default settings for the language detector\ntype LanguageDetectorOptions = {\n  order?: LanguageDetector[];\n  lookupQuerystring?: string;\n  lookupCookie?: string;\n  lookupLocalStorage?: string;\n  lookupSessionStorage?: string;\n  excludeCacheFor?: string[];\n  htmlTag?: HTMLElement | null;\n};\n\nconst getDefaultsOptions = (): LanguageDetectorOptions => {\n  const { middleware } = getConfiguration();\n\n  return {\n    order: [\n      LanguageDetector.Querystring,\n      LanguageDetector.Cookie,\n      LanguageDetector.Navigator,\n      LanguageDetector.HtmlTag,\n    ],\n    lookupQuerystring: 'locale',\n    lookupCookie: middleware.cookieName,\n    htmlTag: document.documentElement,\n  };\n};\n\n// Helper functions for various checks and operations\nconst isLocalStorageAvailable = (): boolean => {\n  try {\n    if (typeof window === 'undefined') return false;\n    const testKey = 'intlayer.translate.boo';\n    window.localStorage.setItem(testKey, 'foo');\n    window.localStorage.removeItem(testKey);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\nconst isSessionStorageAvailable = (): boolean => {\n  try {\n    if (typeof window === 'undefined') return false;\n    const testKey = 'intlayer.translate.boo';\n    window.sessionStorage.setItem(testKey, 'foo');\n    window.sessionStorage.removeItem(testKey);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n// Function to detect language using different detectors\nconst detectLanguage = (\n  order: string[],\n  options: LanguageDetectorOptions\n): Record<LanguageDetector, Locales | Locales[]> => {\n  const detected: Record<LanguageDetector, Locales | Locales[]> = {} as Record<\n    LanguageDetector,\n    Locales | Locales[]\n  >;\n\n  const queryStringDetector = () => {\n    if (typeof window === 'undefined') return;\n    const search = window.location.search || '';\n    const params = new URLSearchParams(search);\n    const value = params.get(options.lookupQuerystring ?? '');\n    if (value) {\n      detected[LanguageDetector.Querystring] = value as Locales;\n    }\n  };\n\n  const cookieDetector = () => {\n    if (typeof document === 'undefined') return;\n    const cookies = document.cookie.split(';');\n    const cookieName = `${options.lookupCookie ?? ''}=`;\n    const cookie = cookies.find((c) => c.trim().startsWith(cookieName));\n    if (cookie) {\n      const value = cookie.split('=')[1].trim();\n\n      detected[LanguageDetector.Cookie] = value as Locales;\n    }\n  };\n\n  const localStorageDetector = () => {\n    if (!isLocalStorageAvailable()) return;\n    const value = window.localStorage.getItem(options.lookupLocalStorage ?? '');\n    if (value) {\n      detected[LanguageDetector.LocalStorage] = value as Locales;\n    }\n  };\n\n  const sessionStorageDetector = () => {\n    if (!isSessionStorageAvailable()) return;\n    const value = window.sessionStorage.getItem(\n      options.lookupSessionStorage ?? ''\n    );\n    if (value) {\n      detected[LanguageDetector.SessionStorage] = value as Locales;\n    }\n  };\n\n  const navigatorDetector = () => {\n    if (typeof navigator === 'undefined') return;\n\n    if (navigator.language) {\n      detected[LanguageDetector.Navigator] = navigator.language as Locales;\n    }\n  };\n\n  const htmlTagDetector = () => {\n    const htmlTag = options.htmlTag;\n    if (htmlTag && typeof htmlTag.getAttribute === 'function') {\n      const lang = htmlTag.getAttribute('lang');\n      if (lang) {\n        detected[LanguageDetector.HtmlTag] = lang as Locales;\n      }\n    }\n  };\n\n  // Map detector names to their corresponding functions\n  const detectors: Record<string, () => void> = {\n    [LanguageDetector.Querystring]: queryStringDetector,\n    [LanguageDetector.Cookie]: cookieDetector,\n    [LanguageDetector.LocalStorage]: localStorageDetector,\n    [LanguageDetector.SessionStorage]: sessionStorageDetector,\n    [LanguageDetector.Navigator]: navigatorDetector,\n    [LanguageDetector.HtmlTag]: htmlTagDetector,\n  };\n\n  // Use the provided order to run each detector\n  order.forEach((detectorName) => {\n    detectors[detectorName]?.();\n  });\n\n  return detected;\n};\n\nconst getFirstAvailableLocale = (\n  locales: Record<LanguageDetector, Locales | Locales[]>,\n  order: LanguageDetector[]\n): Locales => {\n  const { internationalization } = getConfiguration();\n\n  for (const detector of order) {\n    const localesArray = [locales[detector]].flat() as Locales[];\n\n    for (const locale of localesArray) {\n      if (\n        locale &&\n        (internationalization.locales ?? localeList).includes(locale)\n      ) {\n        return locale;\n      } else if (\n        locale?.includes('-') &&\n        (internationalization.locales ?? localeList).includes(\n          locale.split('-')[0] as Locales\n        )\n      ) {\n        return locale.split('-')[0] as Locales;\n      }\n    }\n  }\n\n  return internationalization.defaultLocale;\n};\n\n/**\n * Core language detector function\n * const detectedLanguages = detectLanguage(['LanguageDetector.Cookie', 'LanguageDetector.LocalStorage'], { lookupCookie: 'myCookie' });\n */\nexport const getBrowserLocale = (\n  userOptions: LanguageDetectorOptions | undefined = {}\n): Locales => {\n  const options = { ...getDefaultsOptions(), ...userOptions };\n\n  const locales = detectLanguage(options.order ?? [], options);\n\n  return getFirstAvailableLocale(locales, options.order ?? []);\n};\n"],"mappings":"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","names":["LanguageDetector"]}

package/dist/cjs/client/getBrowserLocale.d.ts

@@ -0,0 +1,26 @@
+import { Locales } from '@intlayer/config/client';
+
+declare enum LanguageDetector {
+    Querystring = "querystring",
+    Cookie = "cookie",
+    LocalStorage = "localStorage",
+    SessionStorage = "sessionStorage",
+    Navigator = "navigator",
+    HtmlTag = "htmlTag"
+}
+type LanguageDetectorOptions = {
+    order?: LanguageDetector[];
+    lookupQuerystring?: string;
+    lookupCookie?: string;
+    lookupLocalStorage?: string;
+    lookupSessionStorage?: string;
+    excludeCacheFor?: string[];
+    htmlTag?: HTMLElement | null;
+};
+/**
+ * Core language detector function
+ * const detectedLanguages = detectLanguage(['LanguageDetector.Cookie', 'LanguageDetector.LocalStorage'], { lookupCookie: 'myCookie' });
+ */
+declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locales;
+
+export { LanguageDetector, getBrowserLocale };

package/dist/cjs/client/index.cjs

@@ -18,31 +18,37 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var client_exports = {};
 __export(client_exports, {
-  LocaleClientContext: () => import_LocaleClientContextProvider.LocaleClientContext,
-  LocaleClientContextProvider: () => import_LocaleClientContextProvider.LocaleClientContextProvider,
+  IntlayerClient: () => import_IntlayerClientProvider.IntlayerClientContext,
+  IntlayerClientProvider: () => import_IntlayerClientProvider.IntlayerClientProvider,
+  getBrowserLocale: () => import_getBrowserLocale.getBrowserLocale,
   localeCookie: () => import_useLocaleCookie.localeCookie,
   setLocaleCookie: () => import_useLocaleCookie.setLocaleCookie,
   useIntlayer: () => import_useIntlayer.useIntlayer,
+  useIntlayerContext: () => import_IntlayerClientProvider.useIntlayerContext,
   useLocale: () => import_useLocale.useLocale,
-  useLocaleContext: () => import_LocaleClientContextProvider.useLocaleContext,
+  useLocaleBase: () => import_useLocaleBase.useLocaleBase,
   useLocaleCookie: () => import_useLocaleCookie.useLocaleCookie,
   useTraduction: () => import_useTraduction.useTraduction
 });
 module.exports = __toCommonJS(client_exports);
-var import_LocaleClientContextProvider = require('./LocaleClientContextProvider.cjs');
+var import_IntlayerClientProvider = require('./IntlayerClientProvider.cjs');
 var import_useIntlayer = require('./useIntlayer.cjs');
+var import_useLocaleBase = require('./useLocaleBase.cjs');
 var import_useLocale = require('./useLocale.cjs');
 var import_useTraduction = require('./useTraduction.cjs');
 var import_useLocaleCookie = require('./useLocaleCookie.cjs');
+var import_getBrowserLocale = require('./getBrowserLocale.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LocaleClientContext,
-  LocaleClientContextProvider,
+  IntlayerClient,
+  IntlayerClientProvider,
+  getBrowserLocale,
   localeCookie,
   setLocaleCookie,
   useIntlayer,
+  useIntlayerContext,
   useLocale,
-  useLocaleContext,
+  useLocaleBase,
   useLocaleCookie,
   useTraduction
 });

package/dist/cjs/client/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["export type { LocaleClientContextProviderProps } from './LocaleClientContextProvider';\nexport {\n  LocaleClientContext,\n  useLocaleContext,\n  LocaleClientContextProvider,\n} from './LocaleClientContextProvider';\nexport { useIntlayer } from './useIntlayer';\nexport { useLocale } from './useLocale';\nexport { useTraduction } from './useTraduction';\nexport {\n  useLocaleCookie,\n  localeCookie,\n  setLocaleCookie,\n} from './useLocaleCookie';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,yCAIO;AACP,yBAA4B;AAC5B,uBAA0B;AAC1B,2BAA8B;AAC9B,6BAIO;","names":[]}
+{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["export type { IntlayerClientProviderProps } from './IntlayerClientProvider';\nexport {\n  IntlayerClientContext as IntlayerClient,\n  useIntlayerContext,\n  IntlayerClientProvider,\n} from './IntlayerClientProvider';\nexport { useIntlayer } from './useIntlayer';\nexport { useLocaleBase } from './useLocaleBase';\nexport { useLocale } from './useLocale';\nexport { useTraduction } from './useTraduction';\nexport {\n  useLocaleCookie,\n  localeCookie,\n  setLocaleCookie,\n} from './useLocaleCookie';\nexport { getBrowserLocale } from './getBrowserLocale';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAIO;AACP,yBAA4B;AAC5B,2BAA8B;AAC9B,uBAA0B;AAC1B,2BAA8B;AAC9B,6BAIO;AACP,8BAAiC;","names":[]}

package/dist/cjs/client/index.d.ts

@@ -1,8 +1,10 @@
-export { LocaleClientContext, LocaleClientContextProvider, LocaleClientContextProviderProps, useLocaleContext } from './LocaleClientContextProvider.js';
+export { IntlayerClientContext as IntlayerClient, IntlayerClientProvider, IntlayerClientProviderProps, useIntlayerContext } from './IntlayerClientProvider.js';
 export { useIntlayer } from './useIntlayer.js';
+export { useLocaleBase } from './useLocaleBase.js';
 export { useLocale } from './useLocale.js';
 export { useTraduction } from './useTraduction.js';
 export { localeCookie, setLocaleCookie, useLocaleCookie } from './useLocaleCookie.js';
+export { getBrowserLocale } from './getBrowserLocale.js';
 import 'react';
 import '@intlayer/config/client';
 import '../useIntlayerBase.js';

package/dist/cjs/client/useContent.cjs

@@ -21,10 +21,10 @@ __export(useContent_exports, {
   useContent: () => useContent
 });
 module.exports = __toCommonJS(useContent_exports);
-var import_useLocale = require('./useLocale.cjs');
+var import_useLocaleBase = require('./useLocaleBase.cjs');
 var import_useTraduction = require('./useTraduction.cjs');
 const useContent = (languageContent) => {
-  const { locale } = (0, import_useLocale.useLocale)();
+  const { locale } = (0, import_useLocaleBase.useLocaleBase)();
   const content = (0, import_useTraduction.useTraduction)(languageContent);
   return {
     locale,

package/dist/cjs/client/useContent.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/client/useContent.ts"],"sourcesContent":["import type { LanguageContent } from '@intlayer/core';\nimport { useLocale } from './useLocale';\nimport { useTraduction } from './useTraduction';\n\nexport const useContent = <Content>(\n  languageContent: LanguageContent<Content>\n) => {\n  const { locale } = useLocale();\n\n  const content = useTraduction(languageContent);\n\n  return {\n    locale,\n    content,\n    t: useTraduction,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,uBAA0B;AAC1B,2BAA8B;AAEvB,MAAM,aAAa,CACxB,oBACG;AACH,QAAM,EAAE,OAAO,QAAI,4BAAU;AAE7B,QAAM,cAAU,oCAAc,eAAe;AAE7C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL;AACF;","names":[]}
+{"version":3,"sources":["../../../src/client/useContent.ts"],"sourcesContent":["import type { LanguageContent } from '@intlayer/core';\nimport { useLocaleBase } from './useLocaleBase';\nimport { useTraduction } from './useTraduction';\n\n/**\n * On the client side, hook to get the translation content based on the locale\n */\nexport const useContent = <Content>(\n  languageContent: LanguageContent<Content>\n) => {\n  const { locale } = useLocaleBase();\n\n  const content = useTraduction(languageContent);\n\n  return {\n    locale,\n    content,\n    t: useTraduction,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,2BAA8B;AAC9B,2BAA8B;AAKvB,MAAM,aAAa,CACxB,oBACG;AACH,QAAM,EAAE,OAAO,QAAI,oCAAc;AAEjC,QAAM,cAAU,oCAAc,eAAe;AAE7C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL;AACF;","names":[]}

package/dist/cjs/client/useContent.d.ts

@@ -2,10 +2,13 @@ import * as _intlayer_config_client from '@intlayer/config/client';
 import * as intlayer from 'intlayer';
 import { LanguageContent } from '@intlayer/core';
 
+/**
+ * On the client side, hook to get the translation content based on the locale
+ */
 declare const useContent: <Content>(languageContent: LanguageContent<Content>) => {
     locale: intlayer.Locales;
     content: Content;
-    t: <Content_1>(languageContent: Partial<Record<_intlayer_config_client.LocalesValues, Content_1>>) => Content_1;
+    t: <Content_1 = string>(languageContent: Partial<Record<_intlayer_config_client.LocalesValues, Content_1>>) => Content_1;
 };
 
 export { useContent };

package/dist/cjs/client/useIntlayer.cjs

@@ -24,9 +24,9 @@ __export(useIntlayer_exports, {
 module.exports = __toCommonJS(useIntlayer_exports);
 var import_react = require("react");
 var import_useIntlayerBase = require('../useIntlayerBase.cjs');
-var import_LocaleClientContextProvider = require('./LocaleClientContextProvider.cjs');
+var import_IntlayerClientProvider = require('./IntlayerClientProvider.cjs');
 const useIntlayer = (id, locale) => {
-  const { locale: currentLocale } = (0, import_react.useContext)(import_LocaleClientContextProvider.LocaleClientContext);
+  const { locale: currentLocale } = (0, import_react.useContext)(import_IntlayerClientProvider.IntlayerClientContext);
   const localeTarget = locale ?? currentLocale;
   return (0, import_useIntlayerBase.useIntlayerBase)(id, localeTarget);
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport type { Locales } from '@intlayer/config/client';\nimport { useContext } from 'react';\nimport {\n  type DictionaryKeys,\n  useIntlayerBase,\n  type UseIntlayer,\n} from '../useIntlayerBase';\nimport { LocaleClientContext } from './LocaleClientContextProvider';\n\nexport const useIntlayer: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const { locale: currentLocale } = useContext(LocaleClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return useIntlayerBase(id, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAA2B;AAC3B,6BAIO;AACP,yCAAoC;AAE7B,MAAM,cAA2B,CACtC,IACA,WACG;AACH,QAAM,EAAE,QAAQ,cAAc,QAAI,yBAAW,sDAAmB;AAChE,QAAM,eAAe,UAAU;AAE/B,aAAO,wCAAgB,IAAI,YAAY;AACzC;","names":[]}
+{"version":3,"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport type { Locales } from '@intlayer/config/client';\nimport { useContext } from 'react';\nimport {\n  type DictionaryKeys,\n  useIntlayerBase,\n  type UseIntlayer,\n} from '../useIntlayerBase';\nimport { IntlayerClientContext } from './IntlayerClientProvider';\n\n/**\n * On the client side, Hook that picking one dictionary by its id and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useIntlayer: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return useIntlayerBase(id, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAA2B;AAC3B,6BAIO;AACP,oCAAsC;AAO/B,MAAM,cAA2B,CACtC,IACA,WACG;AACH,QAAM,EAAE,QAAQ,cAAc,QAAI,yBAAW,mDAAqB;AAClE,QAAM,eAAe,UAAU;AAE/B,aAAO,wCAAgB,IAAI,YAAY;AACzC;","names":[]}

package/dist/cjs/client/useIntlayer.d.ts

@@ -2,6 +2,11 @@ import { UseIntlayer } from '../useIntlayerBase.js';
 import '@intlayer/config/client';
 import 'intlayer';
 
+/**
+ * On the client side, Hook that picking one dictionary by its id and return the content
+ *
+ * If the locale is not provided, it will use the locale from the client context
+ */
 declare const useIntlayer: UseIntlayer;
 
 export { useIntlayer };

package/dist/cjs/client/useLocale.cjs

@@ -25,10 +25,10 @@ module.exports = __toCommonJS(useLocale_exports);
 var import_client = require("@intlayer/config/client");
 var import_core = require("@intlayer/core");
 var import_react = require("react");
-var import_LocaleClientContextProvider = require('./LocaleClientContextProvider.cjs');
-const { defaultLocale, locales: availableLocales } = import_client.intlayerIntlConfiguration;
+var import_IntlayerClientProvider = require('./IntlayerClientProvider.cjs');
 const useLocale = () => {
-  const { locale } = (0, import_react.useContext)(import_LocaleClientContextProvider.LocaleClientContext);
+  const { defaultLocale, locales: availableLocales } = (0, import_client.getConfiguration)().internationalization;
+  const { locale, setLocale } = (0, import_react.useContext)(import_IntlayerClientProvider.IntlayerClientContext);
   return {
     locale,
     // Current locale
@@ -36,8 +36,10 @@ const useLocale = () => {
     // Principal locale defined in config
     availableLocales,
     // List of the available locales defined in config
-    localeList: import_core.localeList
+    localeList: import_core.localeList,
     // List of all available locales
+    setLocale
+    // Function to set the locale
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["'use client';\n\nimport { intlayerIntlConfiguration } from '@intlayer/config/client';\nimport { localeList } from '@intlayer/core';\nimport { useContext } from 'react';\nimport { LocaleClientContext } from './LocaleClientContextProvider';\n\nconst { defaultLocale, locales: availableLocales } = intlayerIntlConfiguration;\n\nexport const useLocale = () => {\n  const { locale } = useContext(LocaleClientContext);\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    localeList, // List of all available locales\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAA0C;AAC1C,kBAA2B;AAC3B,mBAA2B;AAC3B,yCAAoC;AAEpC,MAAM,EAAE,eAAe,SAAS,iBAAiB,IAAI;AAE9C,MAAM,YAAY,MAAM;AAC7B,QAAM,EAAE,OAAO,QAAI,yBAAW,sDAAmB;AAEjD,SAAO;AAAA,IACL;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["'use client';\n\nimport { getConfiguration } from '@intlayer/config/client';\nimport { localeList } from '@intlayer/core';\nimport { useContext } from 'react';\nimport { IntlayerClientContext } from './IntlayerClientProvider';\n\n/**\n * On the client side, hook to get the current locale and all related fields\n */\nexport const useLocale = () => {\n  const { defaultLocale, locales: availableLocales } =\n    getConfiguration().internationalization;\n  const { locale, setLocale } = useContext(IntlayerClientContext);\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    localeList, // List of all available locales\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAAiC;AACjC,kBAA2B;AAC3B,mBAA2B;AAC3B,oCAAsC;AAK/B,MAAM,YAAY,MAAM;AAC7B,QAAM,EAAE,eAAe,SAAS,iBAAiB,QAC/C,gCAAiB,EAAE;AACrB,QAAM,EAAE,QAAQ,UAAU,QAAI,yBAAW,mDAAqB;AAE9D,SAAO;AAAA,IACL;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACF;","names":[]}