react-intlayer 1.0.0

package/dist/cjs/client/useLocale.cjs

@@ -0,0 +1,55 @@
+"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 useLocale_exports = {};
+__export(useLocale_exports, {
+  useLocale: () => useLocale,
+});
+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;
+const useLocale = () => {
+  const { locale } = (0, import_react.useContext)(
+    import_LocaleClientContextProvider.LocaleClientContext
+  );
+  return {
+    locale,
+    // Current locale
+    defaultLocale,
+    // Principal locale defined in config
+    availableLocales,
+    // List of the available locales defined in config
+    localeList: import_core.localeList,
+    // List of all available locales
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useLocale,
+  });
+//# sourceMappingURL=useLocale.cjs.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,10 @@
+import * as _intlayer_config_client from "@intlayer/config/client";
+
+declare const useLocale: () => {
+  locale: _intlayer_config_client.Locales;
+  defaultLocale: _intlayer_config_client.Locales;
+  availableLocales: _intlayer_config_client.Locales[];
+  localeList: _intlayer_config_client.Locales[];
+};
+
+export { useLocale };

package/dist/cjs/client/useLocaleCookie.cjs

@@ -0,0 +1,70 @@
+"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 __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 __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 __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLocaleCookie_exports = {};
+__export(useLocaleCookie_exports, {
+  localeCookie: () => localeCookie,
+  setLocaleCookie: () => setLocaleCookie,
+  useLocaleCookie: () => useLocaleCookie,
+});
+module.exports = __toCommonJS(useLocaleCookie_exports);
+var import_client = require("@intlayer/config/client");
+var import_js_cookie = __toESM(require("js-cookie"));
+const { cookieName } = import_client.intlayerMiddlewareConfiguration;
+const cookieAttributes = {
+  path: "/",
+  expires: void 0,
+  domain: void 0,
+  secure: false,
+  sameSite: "strict",
+};
+const localeCookie = import_js_cookie.default.get(cookieName);
+const setLocaleCookie = (locale) => {
+  import_js_cookie.default.set(cookieName, locale, cookieAttributes);
+};
+const useLocaleCookie = () => ({
+  localeCookie,
+  setLocaleCookie,
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    localeCookie,
+    setLocaleCookie,
+    useLocaleCookie,
+  });
+//# sourceMappingURL=useLocaleCookie.cjs.map

package/dist/cjs/client/useLocaleCookie.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useLocaleCookie.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\nimport {\n  type Locales,\n  intlayerMiddlewareConfiguration,\n} from '@intlayer/config/client';\nimport Cookies from 'js-cookie';\n\nconst { cookieName } = intlayerMiddlewareConfiguration;\n\nconst cookieAttributes: Cookies.CookieAttributes = {\n  path: '/',\n  expires: undefined,\n  domain: undefined,\n  secure: false,\n  sameSite: 'strict',\n};\n\nexport const localeCookie = Cookies.get(cookieName) as Locales | undefined;\n\nexport const setLocaleCookie = (locale: Locales) => {\n  Cookies.set(cookieName, locale, cookieAttributes);\n};\n\nexport const useLocaleCookie = () => ({\n  localeCookie,\n  setLocaleCookie,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAGO;AACP,uBAAoB;AAEpB,MAAM,EAAE,WAAW,IAAI;AAEvB,MAAM,mBAA6C;AAAA,EACjD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AACZ;AAEO,MAAM,eAAe,iBAAAA,QAAQ,IAAI,UAAU;AAE3C,MAAM,kBAAkB,CAAC,WAAoB;AAClD,mBAAAA,QAAQ,IAAI,YAAY,QAAQ,gBAAgB;AAClD;AAEO,MAAM,kBAAkB,OAAO;AAAA,EACpC;AAAA,EACA;AACF;","names":["Cookies"]}

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

@@ -0,0 +1,10 @@
+import { Locales } from "@intlayer/config/client";
+
+declare const localeCookie: Locales | undefined;
+declare const setLocaleCookie: (locale: Locales) => void;
+declare const useLocaleCookie: () => {
+  localeCookie: Locales | undefined;
+  setLocaleCookie: (locale: Locales) => void;
+};
+
+export { localeCookie, setLocaleCookie, useLocaleCookie };

package/dist/cjs/client/useTraduction.cjs

@@ -0,0 +1,42 @@
+"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 useTraduction_exports = {};
+__export(useTraduction_exports, {
+  useTraduction: () => useTraduction,
+});
+module.exports = __toCommonJS(useTraduction_exports);
+var import_react = require("react");
+var import_getTranslation = require("../getTranslation.cjs");
+var import_LocaleClientContextProvider = require("./LocaleClientContextProvider.cjs");
+const useTraduction = (languageContent) => {
+  const { locale } = (0, import_react.useContext)(
+    import_LocaleClientContextProvider.LocaleClientContext
+  );
+  return (0, import_getTranslation.getTranslation)(languageContent, locale);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useTraduction,
+  });
+//# sourceMappingURL=useTraduction.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useTraduction.ts"],"sourcesContent":["import type { LanguageContent } from '@intlayer/core';\nimport { useContext } from 'react';\nimport { getTranslation } from '../getTranslation';\nimport { LocaleClientContext } from './LocaleClientContextProvider';\n\nexport const useTraduction = <Content>(\n  languageContent: LanguageContent<Content>\n): Content => {\n  const { locale } = useContext(LocaleClientContext);\n\n  return getTranslation(languageContent, locale);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA2B;AAC3B,4BAA+B;AAC/B,yCAAoC;AAE7B,MAAM,gBAAgB,CAC3B,oBACY;AACZ,QAAM,EAAE,OAAO,QAAI,yBAAW,sDAAmB;AAEjD,aAAO,sCAAe,iBAAiB,MAAM;AAC/C;","names":[]}

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

@@ -0,0 +1,7 @@
+import { LanguageContent } from "@intlayer/core";
+
+declare const useTraduction: <Content>(
+  languageContent: LanguageContent<Content>
+) => Content;
+
+export { useTraduction };

package/dist/cjs/getEnumeration.cjs

@@ -0,0 +1,45 @@
+"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 getEnumeration_exports = {};
+__export(getEnumeration_exports, {
+  getEnumeration: () => getEnumeration,
+});
+module.exports = __toCommonJS(getEnumeration_exports);
+var import_core = require("@intlayer/core");
+var import_contentRender = require("./ContentEditor/contentRender.cjs");
+const getEnumeration = (enumerationContent, quantity) => {
+  const result = (0, import_core.getEnumerationContent)(
+    enumerationContent,
+    quantity
+  );
+  if (typeof result === "string") {
+    return (0, import_contentRender.contentRender)(result);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getEnumeration,
+  });
+//# sourceMappingURL=getEnumeration.cjs.map

package/dist/cjs/getEnumeration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getEnumeration.ts"],"sourcesContent":["import { type QuantityContent, getEnumerationContent } from '@intlayer/core';\nimport { contentRender } from './ContentEditor/contentRender';\n\nexport const getEnumeration = <Content>(\n  enumerationContent: QuantityContent<Content>,\n  quantity: number\n): Content => {\n  const result: Content = getEnumerationContent<Content>(\n    enumerationContent,\n    quantity\n  );\n\n  if (typeof result === 'string') {\n    return contentRender(result) as Content;\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA4D;AAC5D,2BAA8B;AAEvB,MAAM,iBAAiB,CAC5B,oBACA,aACY;AACZ,QAAM,aAAkB;AAAA,IACtB;AAAA,IACA;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,UAAU;AAC9B,eAAO,oCAAc,MAAM;AAAA,EAC7B;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/getEnumeration.d.ts

@@ -0,0 +1,8 @@
+import { QuantityContent } from "@intlayer/core";
+
+declare const getEnumeration: <Content>(
+  enumerationContent: QuantityContent<Content>,
+  quantity: number
+) => Content;
+
+export { getEnumeration };

package/dist/cjs/getTranslation.cjs

@@ -0,0 +1,47 @@
+"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 getTranslation_exports = {};
+__export(getTranslation_exports, {
+  getTranslation: () => getTranslation,
+});
+module.exports = __toCommonJS(getTranslation_exports);
+var import_client = require("@intlayer/config/client");
+var import_core = require("@intlayer/core");
+var import_contentRender = require("./ContentEditor/contentRender.cjs");
+const getTranslation = (languageContent, locale) => {
+  const { defaultLocale } = import_client.intlayerIntlConfiguration;
+  const result = (0, import_core.getTranslationContent)(
+    languageContent,
+    locale ?? defaultLocale
+  );
+  if (typeof result === "string") {
+    return (0, import_contentRender.contentRender)(result);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getTranslation,
+  });
+//# sourceMappingURL=getTranslation.cjs.map

package/dist/cjs/getTranslation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getTranslation.ts"],"sourcesContent":["import {\n  type Locales,\n  intlayerIntlConfiguration,\n} from '@intlayer/config/client';\nimport { type LanguageContent, getTranslationContent } from '@intlayer/core';\nimport { contentRender } from './ContentEditor/contentRender';\n\nexport const getTranslation = <Content>(\n  languageContent: LanguageContent<Content>,\n  locale?: Locales\n): Content => {\n  const { defaultLocale } = intlayerIntlConfiguration;\n\n  const result: Content = getTranslationContent<Content>(\n    languageContent,\n    locale ?? defaultLocale\n  );\n\n  if (typeof result === 'string') {\n    return contentRender(result) as Content;\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAGO;AACP,kBAA4D;AAC5D,2BAA8B;AAEvB,MAAM,iBAAiB,CAC5B,iBACA,WACY;AACZ,QAAM,EAAE,cAAc,IAAI;AAE1B,QAAM,aAAkB;AAAA,IACtB;AAAA,IACA,UAAU;AAAA,EACZ;AAEA,MAAI,OAAO,WAAW,UAAU;AAC9B,eAAO,oCAAc,MAAM;AAAA,EAC7B;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/getTranslation.d.ts

@@ -0,0 +1,9 @@
+import { Locales } from "@intlayer/config/client";
+import { LanguageContent } from "@intlayer/core";
+
+declare const getTranslation: <Content>(
+  languageContent: LanguageContent<Content>,
+  locale?: Locales
+) => Content;
+
+export { getTranslation };

package/dist/cjs/index.cjs

@@ -0,0 +1,53 @@
+"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 src_exports = {};
+__export(src_exports, {
+  LocaleClientContext: () => import_client.LocaleClientContext,
+  LocaleClientContextProvider: () => import_client.LocaleClientContextProvider,
+  getTranslation: () => import_getTranslation.getTranslation,
+  localeCookie: () => import_client.localeCookie,
+  setLocaleCookie: () => import_client.setLocaleCookie,
+  useIntlayer: () => import_client.useIntlayer,
+  useLocale: () => import_client.useLocale,
+  useLocaleContext: () => import_client.useLocaleContext,
+  useLocaleCookie: () => import_client.useLocaleCookie,
+  useTraduction: () => import_client.useTraduction,
+});
+module.exports = __toCommonJS(src_exports);
+var import_getTranslation = require("./getTranslation.cjs");
+var import_client = require("./client/index.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleClientContext,
+    LocaleClientContextProvider,
+    getTranslation,
+    localeCookie,
+    setLocaleCookie,
+    useIntlayer,
+    useLocale,
+    useLocaleContext,
+    useLocaleCookie,
+    useTraduction,
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export { getTranslation } from './getTranslation';\nexport {\n  LocaleClientContextProvider,\n  type LocaleClientContextProviderProps,\n  LocaleClientContext,\n  useLocaleContext,\n  useIntlayer,\n  useLocale,\n  useTraduction,\n  useLocaleCookie,\n  localeCookie,\n  setLocaleCookie,\n} from './client/index';\nexport {} from './client/useLocaleCookie';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAA+B;AAC/B,oBAWO;","names":[]}

package/dist/cjs/index.d.ts

@@ -0,0 +1,20 @@
+export { getTranslation } from "./getTranslation.js";
+export {
+  LocaleClientContext,
+  LocaleClientContextProvider,
+  LocaleClientContextProviderProps,
+  useLocaleContext,
+} from "./client/LocaleClientContextProvider.js";
+export { useIntlayer } from "./client/useIntlayer.js";
+export { useLocale } from "./client/useLocale.js";
+export { useTraduction } from "./client/useTraduction.js";
+export {
+  localeCookie,
+  setLocaleCookie,
+  useLocaleCookie,
+} from "./client/useLocaleCookie.js";
+import "@intlayer/config/client";
+import "@intlayer/core";
+import "react";
+import "./useIntlayerBase.js";
+import "intlayer";

package/dist/cjs/processDictionary/contentDictionary.d.cjs

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contentDictionary_d_exports = {};
+module.exports = __toCommonJS(contentDictionary_d_exports);
+//# sourceMappingURL=contentDictionary.d.cjs.map

package/dist/cjs/processDictionary/contentDictionary.d.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/processDictionary/contentDictionary.d.ts"],"sourcesContent":["import { type TranslationContent } from '@intlayer/core';\n\nexport type ContentValue =\n  | string\n  | {\n      [key: string]: ContentValue;\n    }\n  | TranslationContent<unknown>;\n\nexport type Content = Record<string, ContentValue | undefined>;\n\nexport type TransformedContentValue =\n  | string\n  | {\n      [key: string]: TransformedContentValue;\n    }\n  | undefined\n  | ((quantity: number) => TransformedContentValue);\n\nexport type TransformedContent = Record<\n  string,\n  TransformedContentValue | undefined\n>;\n\nexport type ContentDictionary = Content & {\n  id: string;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/cjs/processDictionary/contentDictionary.d.d.ts

@@ -0,0 +1,32 @@
+import { TranslationContent } from "@intlayer/core";
+
+type ContentValue =
+  | string
+  | {
+      [key: string]: ContentValue;
+    }
+  | TranslationContent<unknown>;
+
+type Content = Record<string, ContentValue | undefined>;
+
+type TransformedContentValue =
+  | string
+  | {
+      [key: string]: TransformedContentValue;
+    }
+  | undefined
+  | ((quantity: number) => TransformedContentValue);
+
+type TransformedContent = Record<string, TransformedContentValue | undefined>;
+
+type ContentDictionary = Content & {
+  id: string;
+};
+
+export type {
+  Content,
+  ContentDictionary,
+  ContentValue,
+  TransformedContent,
+  TransformedContentValue,
+};

package/dist/cjs/processDictionary/index.cjs

@@ -0,0 +1,82 @@
+"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 processDictionary_exports = {};
+__export(processDictionary_exports, {
+  processDictionary: () => processDictionary,
+  processNode: () => processNode,
+});
+module.exports = __toCommonJS(processDictionary_exports);
+var import_client = require("@intlayer/config/client");
+var import_core = require("@intlayer/core");
+var import_getEnumeration = require("../getEnumeration.cjs");
+var import_getTranslation = require("../getTranslation.cjs");
+const defaultLocale = import_client.intlayerIntlConfiguration.defaultLocale;
+const processTranslation = (languageContent, locale) => {
+  const translationResult = (0, import_getTranslation.getTranslation)(
+    languageContent,
+    locale
+  );
+  return processDictionary(translationResult, locale);
+};
+const processEnumeration = (enumerationContent, locale) => {
+  return (quantity) => {
+    const enumerationResult = (0, import_getEnumeration.getEnumeration)(
+      enumerationContent,
+      quantity
+    );
+    return processDictionary(enumerationResult, locale);
+  };
+};
+const processNode = (field, locale) => {
+  if (typeof field !== "object" || field === null) {
+    return field;
+  }
+  if (field.nodeType === import_core.NodeType.Translation) {
+    return processTranslation(field, locale);
+  }
+  if (field.nodeType === import_core.NodeType.Enumeration) {
+    return processEnumeration(field, locale);
+  }
+  if (typeof field.type === "undefined") {
+    return processDictionary(field, locale);
+  }
+  return field;
+};
+const processDictionary = (content, locale = defaultLocale) => {
+  if (content && typeof content === "object") {
+    const result = {};
+    for (const key of Object.keys(content)) {
+      const field = content[key];
+      result[key] = processNode(field, locale);
+    }
+    return result;
+  }
+  return content;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    processDictionary,
+    processNode,
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/processDictionary/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/processDictionary/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  type Locales,\n  intlayerIntlConfiguration,\n} from '@intlayer/config/client';\nimport {\n  NodeType,\n  type QuantityContent,\n  type LanguageContent,\n} from '@intlayer/core';\nimport { getEnumeration } from '../getEnumeration';\nimport { getTranslation } from '../getTranslation';\nimport type {\n  Content,\n  ContentValue,\n  TransformedContent,\n  TransformedContentValue,\n} from './contentDictionary';\n\nconst defaultLocale = intlayerIntlConfiguration.defaultLocale;\n\nconst processTranslation = (\n  languageContent: LanguageContent<ContentValue>,\n  locale: Locales\n): TransformedContent => {\n  const translationResult: ContentValue = getTranslation<ContentValue>(\n    languageContent,\n    locale\n  );\n\n  return processDictionary(translationResult as Content, locale);\n};\n\nconst processEnumeration = (\n  enumerationContent: QuantityContent<ContentValue>,\n  locale: Locales\n): TransformedContentValue => {\n  return (quantity: number): TransformedContentValue => {\n    const enumerationResult: ContentValue = getEnumeration<ContentValue>(\n      enumerationContent,\n      quantity\n    );\n\n    //\n    return processDictionary(enumerationResult as Content, locale);\n  };\n};\n\nexport const processNode = (\n  field: ContentValue | undefined,\n  locale: Locales\n): TransformedContentValue => {\n  if (typeof field !== 'object' || field === null) {\n    return field;\n  }\n\n  if (field.nodeType === NodeType.Translation) {\n    return processTranslation(field as LanguageContent<ContentValue>, locale);\n  }\n\n  if (field.nodeType === NodeType.Enumeration) {\n    return processEnumeration(\n      field satisfies QuantityContent<ContentValue>,\n      locale\n    );\n  }\n\n  if (typeof (field as any).type === 'undefined') {\n    return processDictionary(field as Content, locale);\n  }\n\n  return field as TransformedContentValue;\n};\n\n/**\n * Function to replace the multi lingual content with content in the current locale\n */\nexport const processDictionary = (\n  content: Content,\n  locale: Locales = defaultLocale\n): TransformedContent => {\n  if (content && typeof content === 'object') {\n    const result: TransformedContent = {};\n\n    // List each key in the content and process it\n    for (const key of Object.keys(content)) {\n      const field = content[key];\n\n      result[key] = processNode(field, locale);\n    }\n\n    return result;\n  }\n\n  // If it's a string, number, or function, return it\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAGO;AACP,kBAIO;AACP,4BAA+B;AAC/B,4BAA+B;AAQ/B,MAAM,gBAAgB,wCAA0B;AAEhD,MAAM,qBAAqB,CACzB,iBACA,WACuB;AACvB,QAAM,wBAAkC;AAAA,IACtC;AAAA,IACA;AAAA,EACF;AAEA,SAAO,kBAAkB,mBAA8B,MAAM;AAC/D;AAEA,MAAM,qBAAqB,CACzB,oBACA,WAC4B;AAC5B,SAAO,CAAC,aAA8C;AACpD,UAAM,wBAAkC;AAAA,MACtC;AAAA,MACA;AAAA,IACF;AAGA,WAAO,kBAAkB,mBAA8B,MAAM;AAAA,EAC/D;AACF;AAEO,MAAM,cAAc,CACzB,OACA,WAC4B;AAC5B,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,aAAa,qBAAS,aAAa;AAC3C,WAAO,mBAAmB,OAAwC,MAAM;AAAA,EAC1E;AAEA,MAAI,MAAM,aAAa,qBAAS,aAAa;AAC3C,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAQ,MAAc,SAAS,aAAa;AAC9C,WAAO,kBAAkB,OAAkB,MAAM;AAAA,EACnD;AAEA,SAAO;AACT;AAKO,MAAM,oBAAoB,CAC/B,SACA,SAAkB,kBACK;AACvB,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,UAAM,SAA6B,CAAC;AAGpC,eAAW,OAAO,OAAO,KAAK,OAAO,GAAG;AACtC,YAAM,QAAQ,QAAQ,GAAG;AAEzB,aAAO,GAAG,IAAI,YAAY,OAAO,MAAM;AAAA,IACzC;AAEA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;","names":[]}

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

@@ -0,0 +1,22 @@
+import { Locales } from "@intlayer/config/client";
+import {
+  ContentValue,
+  TransformedContentValue,
+  Content,
+  TransformedContent,
+} from "./contentDictionary.d.js";
+import "@intlayer/core";
+
+declare const processNode: (
+  field: ContentValue | undefined,
+  locale: Locales
+) => TransformedContentValue;
+/**
+ * Function to replace the multi lingual content with content in the current locale
+ */
+declare const processDictionary: (
+  content: Content,
+  locale?: Locales
+) => TransformedContent;
+
+export { processDictionary, processNode };

package/dist/cjs/server/LocaleServerContextProvider.cjs

@@ -0,0 +1,49 @@
+"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 LocaleServerContextProvider_exports = {};
+__export(LocaleServerContextProvider_exports, {
+  LocaleServerContext: () => LocaleServerContext,
+  LocaleServerContextProvider: () => LocaleServerContextProvider,
+  locale: () => locale,
+});
+module.exports = __toCommonJS(LocaleServerContextProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = require("@intlayer/config/client");
+var import_serverContext = require("./serverContext.cjs");
+const LocaleServerContext = (0, import_serverContext.createServerContext)(
+  import_client.intlayerIntlConfiguration.defaultLocale
+);
+const locale = (0, import_serverContext.getServerContext)(LocaleServerContext);
+const LocaleServerContextProvider = ({ children, locale: locale2 }) =>
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocaleServerContext.Provider, {
+    value: locale2,
+    children,
+  });
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleServerContext,
+    LocaleServerContextProvider,
+    locale,
+  });
+//# sourceMappingURL=LocaleServerContextProvider.cjs.map

package/dist/cjs/server/LocaleServerContextProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/LocaleServerContextProvider.tsx"],"sourcesContent":["import {\n  type Locales,\n  intlayerIntlConfiguration,\n} from '@intlayer/config/client';\nimport type { FC, PropsWithChildren } from 'react';\nimport { createServerContext, getServerContext } from './serverContext';\n\nexport const LocaleServerContext = createServerContext<Locales>(\n  intlayerIntlConfiguration.defaultLocale\n);\n\nexport const locale = getServerContext(LocaleServerContext);\n\nexport type LocaleServerContextProviderProps = PropsWithChildren & {\n  locale: Locales;\n};\n\nexport const LocaleServerContextProvider: FC<\n  LocaleServerContextProviderProps\n> = ({ children, locale }) => (\n  <LocaleServerContext.Provider value={locale}>\n    {children}\n  </LocaleServerContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBE;AApBF,oBAGO;AAEP,2BAAsD;AAE/C,MAAM,0BAAsB;AAAA,EACjC,wCAA0B;AAC5B;AAEO,MAAM,aAAS,uCAAiB,mBAAmB;AAMnD,MAAM,8BAET,CAAC,EAAE,UAAU,QAAAA,QAAO,MACtB,4CAAC,oBAAoB,UAApB,EAA6B,OAAOA,SAClC,UACH;","names":["locale"]}