react-intlayer 2.0.0 → 2.0.2

package/dist/cjs/processDictionary/index.cjs

@@ -24,7 +24,6 @@ __export(processDictionary_exports, {
 module.exports = __toCommonJS(processDictionary_exports);
 var import_client = require("@intlayer/config/client");
 var import_core = require("@intlayer/core");
-var import_client2 = require("intlayer-editor/client");
 var import_react = require("react");
 var import_getEnumeration = require('../getEnumeration.cjs');
 var import_getTranslation = require('../getTranslation.cjs');
@@ -48,35 +47,33 @@ const processTranslation = (languageContent, locale, dictionaryId, dictionaryPat
     locale
   );
 };
-const processEnumeration = (enumerationContent, locale, dictionaryId, dictionaryPath, keyPath = []) => {
-  return (quantity) => {
-    const enumerationResult = (0, import_getEnumeration.getEnumeration)(
-      enumerationContent,
-      quantity
-    );
-    const matchingCondition = (0, import_core.findMatchingCondition)(
-      enumerationContent,
-      quantity
-    );
-    const resultKeyPath = [
-      ...keyPath,
-      { type: import_core.NodeType.Enumeration, key: matchingCondition.toString() }
-    ];
-    return processDictionary(
-      enumerationResult,
-      dictionaryId,
-      dictionaryPath,
-      resultKeyPath,
-      locale
-    );
-  };
+const processEnumeration = (enumerationContent, locale, dictionaryId, dictionaryPath, keyPath = []) => (quantity) => {
+  const enumerationResult = (0, import_getEnumeration.getEnumeration)(
+    enumerationContent,
+    quantity
+  );
+  const matchingCondition = (0, import_core.findMatchingCondition)(
+    enumerationContent,
+    quantity
+  );
+  const resultKeyPath = [
+    ...keyPath,
+    { type: import_core.NodeType.Enumeration, key: matchingCondition.toString() }
+  ];
+  return processDictionary(
+    enumerationResult,
+    dictionaryId,
+    dictionaryPath,
+    resultKeyPath,
+    locale
+  );
 };
 const isReactNode = (node) => typeof node?.key !== "undefined" && typeof node?.props !== "undefined";
 const processNode = (field, locale, dictionaryId, dictionaryPath, keyPath = []) => {
   if (typeof field === "object") {
     if (field.nodeType === import_core.NodeType.Translation) {
       return processTranslation(
-        field,
+        field[import_core.NodeType.Translation],
         locale,
         dictionaryId,
         dictionaryPath,
@@ -85,7 +82,7 @@ const processNode = (field, locale, dictionaryId, dictionaryPath, keyPath = [])
     }
     if (field.nodeType === import_core.NodeType.Enumeration) {
       return processEnumeration(
-        field,
+        field[import_core.NodeType.Enumeration],
         locale,
         dictionaryId,
         dictionaryPath,
@@ -126,7 +123,7 @@ const createReactElement = (element) => {
   const { type, props } = fixedElement;
   return (0, import_react.createElement)(type ?? "div", props, ...props.children);
 };
-const traceKeys = ["filePath", "id", "nodeType"];
+const traceKeys = ["filePath", "nodeType"];
 const processDictionary = (content, dictionaryId, dictionaryPath, keyPath = [], locale = defaultLocale) => {
   if (isReactNode(content)) {
     return createReactElement(
@@ -134,40 +131,59 @@ const processDictionary = (content, dictionaryId, dictionaryPath, keyPath = [],
     );
   }
   if (content && typeof content === "object") {
-    const result = {};
-    for (const key of Object.keys(content)) {
-      const field = content[key];
-      if (traceKeys.includes(key)) {
-        result[key] = field;
-        continue;
-      }
-      const resultKeyPath = [
-        ...keyPath,
-        { type: "ObjectExpression", key }
-      ];
-      result[key] = processNode(
-        field,
-        locale,
-        dictionaryId,
-        dictionaryPath,
-        resultKeyPath
-      );
-    }
-    return result;
-  }
-  if (typeof content === "string") {
-    try {
-      return (0, import_client2.renderContentEditor)(
+    const isArray = Array.isArray(content);
+    let result = {};
+    if (typeof content.nodeType !== "undefined") {
+      return processNode(
         content,
+        locale,
         dictionaryId,
         dictionaryPath,
         keyPath
       );
-    } catch (e) {
-      return content;
+    } else if (isArray) {
+      result = content.map((field, key) => {
+        const resultKeyPath = [
+          ...keyPath,
+          { type: "ArrayExpression", key }
+        ];
+        return processNode(
+          field,
+          locale,
+          dictionaryId,
+          dictionaryPath,
+          resultKeyPath
+        );
+      });
+    } else {
+      for (const key of Object.keys(content)) {
+        const field = content[key];
+        if (traceKeys.includes(key)) {
+          result[key] = field;
+          continue;
+        }
+        const resultKeyPath = [
+          ...keyPath,
+          { type: "ObjectExpression", key }
+        ];
+        const nodeResult = processNode(
+          field,
+          locale,
+          dictionaryId,
+          dictionaryPath,
+          resultKeyPath
+        );
+        result[key] = nodeResult;
+      }
     }
+    return result;
   }
-  return content;
+  return {
+    content,
+    keyPath,
+    dictionaryId,
+    dictionaryPath
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/processDictionary/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { type Locales, getConfiguration } from '@intlayer/config/client';\nimport {\n  NodeType,\n  type QuantityContent,\n  type LanguageContent,\n  findMatchingCondition,\n  type KeyPath,\n} from '@intlayer/core';\nimport { renderContentEditor } from 'intlayer-editor/client';\nimport { type ReactElement, createElement, type ReactNode } from 'react';\nimport { getEnumeration } from '../getEnumeration';\nimport { getTranslation } from '../getTranslation';\nimport type {\n  Content,\n  ContentValue,\n  TransformedContent,\n  TransformedContentValue,\n} from './contentDictionary';\n\nconst {\n  internationalization: { defaultLocale },\n} = getConfiguration();\n\nconst processTranslation = (\n  languageContent: LanguageContent<ContentValue>,\n  locale: Locales,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = []\n): TransformedContent => {\n  const translationResult: ContentValue = getTranslation<ContentValue>(\n    languageContent,\n    locale\n  );\n\n  const resultKeyPath: KeyPath[] = [\n    ...keyPath,\n    { type: NodeType.Translation, key: locale },\n  ];\n\n  return processDictionary(\n    translationResult as Content,\n    dictionaryId,\n    dictionaryPath,\n    resultKeyPath,\n    locale\n  );\n};\n\nconst processEnumeration = (\n  enumerationContent: QuantityContent<ContentValue>,\n  locale: Locales,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = []\n): TransformedContentValue => {\n  return (quantity: number): TransformedContentValue => {\n    const enumerationResult: ContentValue = getEnumeration<ContentValue>(\n      enumerationContent,\n      quantity\n    );\n\n    const matchingCondition = findMatchingCondition(\n      enumerationContent,\n      quantity\n    );\n\n    const resultKeyPath: KeyPath[] = [\n      ...keyPath,\n      { type: NodeType.Enumeration, key: matchingCondition.toString() },\n    ];\n\n    //\n    return processDictionary(\n      enumerationResult as Content,\n      dictionaryId,\n      dictionaryPath,\n      resultKeyPath,\n      locale\n    );\n  };\n};\n\nconst isReactNode = (node: Record<string, unknown>): boolean =>\n  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';\n\nexport const processNode = (\n  field: ContentValue | undefined,\n  locale: Locales,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = []\n): TransformedContentValue => {\n  if (typeof field === 'object') {\n    if (field.nodeType === NodeType.Translation) {\n      return processTranslation(\n        field as LanguageContent<ContentValue>,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      );\n    }\n\n    if (field.nodeType === NodeType.Enumeration) {\n      return processEnumeration(\n        field satisfies QuantityContent<ContentValue>,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      );\n    }\n  }\n\n  return processDictionary(\n    field as Content,\n    dictionaryId,\n    dictionaryPath,\n    keyPath,\n    locale\n  );\n};\n\n// This function recursively creates React elements from a given JSON-like structure\nconst createReactElement = (element: ReactElement) => {\n  if (typeof element === 'string') {\n    // If it's a string, simply return it (used for text content)\n    return element;\n  }\n\n  // Destructure the component properties\n\n  const convertChildrenAsArray = (element: ReactElement): ReactElement => {\n    if (element?.props && typeof element.props.children === 'object') {\n      const childrenResult: ReactNode[] = [];\n      const { children } = element.props;\n\n      // Create the children elements recursively, if any\n      Object.keys(children).forEach((key) => {\n        childrenResult.push(createReactElement(children[key]));\n      });\n\n      return {\n        ...element,\n        props: { ...element.props, children: childrenResult },\n      };\n    }\n\n    return {\n      ...element,\n      props: { ...element.props, children: element.props.children },\n    };\n  };\n\n  const fixedElement = convertChildrenAsArray(element);\n\n  const { type, props } = fixedElement;\n\n  // Create and return the React element\n  return createElement(type ?? 'div', props, ...props.children);\n};\n\nconst traceKeys: string[] = ['filePath', 'id', 'nodeType'];\n\n/**\n * Function that process a dictionary and return the result to be used in the application.\n */\nexport const processDictionary = (\n  content: Content,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = [],\n  locale: Locales = defaultLocale\n): TransformedContent => {\n  // If it's a React element, render it\n  if (isReactNode(content)) {\n    return createReactElement(\n      content as unknown as ReactElement\n    ) as unknown as TransformedContent;\n  }\n\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      if (traceKeys.includes(key)) {\n        result[key] = field as TransformedContentValue;\n        continue;\n      }\n\n      const resultKeyPath: KeyPath[] = [\n        ...keyPath,\n        { type: 'ObjectExpression', key },\n      ];\n\n      result[key] = processNode(\n        field,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        resultKeyPath\n      );\n    }\n\n    return result;\n  }\n\n  if (typeof content === 'string') {\n    try {\n      // renderContentEditor come from intlayer-editor, which is an optional dependency.\n      // intlayer-editor should be installed in the project to use the content editor.\n      return renderContentEditor(\n        content,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      );\n    } catch (e) {\n      // If renderContentEditor not available, it will return the content as is.\n      return content;\n    }\n  }\n\n  // If it's a string, number, or function, return it\n  return content;\n};\n"],"mappings":"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","names":["import_client","element"]}
+{"version":3,"sources":["../../../src/processDictionary/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { type Locales, getConfiguration } from '@intlayer/config/client';\nimport {\n  NodeType,\n  type QuantityContent,\n  type LanguageContent,\n  findMatchingCondition,\n  type KeyPath,\n  type Dictionary,\n  type DictionaryValue,\n  type TranslationContent,\n  type EnumerationContent,\n  type TypedNode,\n} from '@intlayer/core';\nimport { type ReactElement, createElement, type ReactNode } from 'react';\nimport { getEnumeration } from '../getEnumeration';\nimport { getTranslation } from '../getTranslation';\nimport type {\n  TransformedContent,\n  TransformedContentValue,\n} from './contentDictionary';\n\nconst {\n  internationalization: { defaultLocale },\n} = getConfiguration();\n\nconst processTranslation = (\n  languageContent: LanguageContent<DictionaryValue>,\n  locale: Locales,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = []\n): TransformedContent => {\n  const translationResult: DictionaryValue = getTranslation<DictionaryValue>(\n    languageContent,\n    locale\n  );\n\n  const resultKeyPath: KeyPath[] = [\n    ...keyPath,\n    { type: NodeType.Translation, key: locale },\n  ];\n\n  return processDictionary(\n    translationResult,\n    dictionaryId,\n    dictionaryPath,\n    resultKeyPath,\n    locale\n  );\n};\n\nconst processEnumeration =\n  (\n    enumerationContent: QuantityContent<DictionaryValue>,\n    locale: Locales,\n    dictionaryId: string,\n    dictionaryPath: string,\n    keyPath: KeyPath[] = []\n  ): TransformedContentValue =>\n  (quantity: number): TransformedContentValue => {\n    const enumerationResult: DictionaryValue = getEnumeration<DictionaryValue>(\n      enumerationContent,\n      quantity\n    );\n\n    const matchingCondition = findMatchingCondition(\n      enumerationContent,\n      quantity\n    );\n\n    const resultKeyPath: KeyPath[] = [\n      ...keyPath,\n      { type: NodeType.Enumeration, key: matchingCondition.toString() },\n    ];\n\n    return processDictionary(\n      enumerationResult,\n      dictionaryId,\n      dictionaryPath,\n      resultKeyPath,\n      locale\n    ) as TransformedContentValue;\n  };\n\nconst isReactNode = (node: Record<string, unknown>): boolean =>\n  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';\n\nexport const processNode = (\n  field: DictionaryValue | undefined,\n  locale: Locales,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = []\n): TransformedContentValue => {\n  if (typeof field === 'object') {\n    if (\n      (field as TranslationContent<DictionaryValue>).nodeType ===\n      NodeType.Translation\n    ) {\n      return processTranslation(\n        field[\n          NodeType.Translation as keyof typeof field\n        ] as LanguageContent<DictionaryValue>,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      ) as TransformedContentValue;\n    }\n\n    if (\n      (field as EnumerationContent<DictionaryValue>).nodeType ===\n      NodeType.Enumeration\n    ) {\n      return processEnumeration(\n        field[\n          NodeType.Enumeration as keyof typeof field\n        ] as QuantityContent<DictionaryValue>,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      );\n    }\n  }\n\n  return processDictionary(\n    field!,\n    dictionaryId,\n    dictionaryPath,\n    keyPath,\n    locale\n  ) as TransformedContentValue;\n};\n\n// This function recursively creates React elements from a given JSON-like structure\nconst createReactElement = (element: ReactElement) => {\n  if (typeof element === 'string') {\n    // If it's a string, simply return it (used for text content)\n    return element;\n  }\n\n  const convertChildrenAsArray = (element: ReactElement): ReactElement => {\n    if (element?.props && typeof element.props.children === 'object') {\n      const childrenResult: ReactNode[] = [];\n      const { children } = element.props;\n\n      // Create the children elements recursively, if any\n      Object.keys(children).forEach((key) => {\n        childrenResult.push(createReactElement(children[key]));\n      });\n\n      return {\n        ...element,\n        props: { ...element.props, children: childrenResult },\n      };\n    }\n\n    return {\n      ...element,\n      props: { ...element.props, children: element.props.children },\n    };\n  };\n\n  const fixedElement = convertChildrenAsArray(element);\n\n  const { type, props } = fixedElement;\n\n  // Create and return the React element\n  return createElement(type ?? 'div', props, ...props.children);\n};\n\nconst traceKeys: string[] = ['filePath', 'nodeType'];\n\n/**\n * Function that process a dictionary and return the result to be used in the application.\n */\nexport const processDictionary = (\n  content: Dictionary | DictionaryValue,\n  dictionaryId: string,\n  dictionaryPath: string,\n  keyPath: KeyPath[] = [],\n  locale: Locales = defaultLocale\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n): TransformedContent => {\n  // If it's a React element, render it\n  if (isReactNode(content as Record<string, unknown>)) {\n    return createReactElement(\n      content as unknown as ReactElement\n    ) as unknown as TransformedContent;\n  }\n\n  if (content && typeof content === 'object') {\n    const isArray = Array.isArray(content);\n\n    let result: TransformedContent = {};\n\n    if (typeof (content as TypedNode).nodeType !== 'undefined') {\n      return processNode(\n        content as DictionaryValue,\n        locale,\n        dictionaryId,\n        dictionaryPath,\n        keyPath\n      ) as TransformedContent;\n    } else if (isArray) {\n      // Eslint fix because promises are awaited during build stage\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      result = (content as DictionaryValue[]).map((field, key) => {\n        const resultKeyPath: KeyPath[] = [\n          ...keyPath,\n          { type: 'ArrayExpression', key },\n        ];\n\n        return processNode(\n          field,\n          locale,\n          dictionaryId,\n          dictionaryPath,\n          resultKeyPath\n        );\n      }) as TransformedContent;\n    } else {\n      // List each key in the content and process it\n      for (const key of Object.keys(content)) {\n        const field = content[key as keyof typeof content];\n\n        if (traceKeys.includes(key)) {\n          result[key] = field as TransformedContentValue;\n          continue;\n        }\n\n        const resultKeyPath: KeyPath[] = [\n          ...keyPath,\n          { type: 'ObjectExpression', key },\n        ];\n\n        const nodeResult = processNode(\n          field,\n          locale,\n          dictionaryId,\n          dictionaryPath,\n          resultKeyPath\n        );\n\n        result[key] = nodeResult;\n      }\n    }\n\n    return result;\n  }\n\n  return {\n    content,\n    keyPath,\n    dictionaryId,\n    dictionaryPath,\n  };\n};\n"],"mappings":"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","names":["element"]}

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

@@ -1,12 +1,12 @@
 import { Locales } from '@intlayer/config/client';
-import { KeyPath } from '@intlayer/core';
-import { ContentValue, TransformedContentValue, Content, TransformedContent } from './contentDictionary.js';
+import { DictionaryValue, KeyPath, Dictionary } from '@intlayer/core';
+import { TransformedContentValue, TransformedContent } from './contentDictionary.js';
 import 'react';
 
-declare const processNode: (field: ContentValue | undefined, locale: Locales, dictionaryId: string, dictionaryPath: string, keyPath?: KeyPath[]) => TransformedContentValue;
+declare const processNode: (field: DictionaryValue | undefined, locale: Locales, dictionaryId: string, dictionaryPath: string, keyPath?: KeyPath[]) => TransformedContentValue;
 /**
  * Function that process a dictionary and return the result to be used in the application.
  */
-declare const processDictionary: (content: Content, dictionaryId: string, dictionaryPath: string, keyPath?: KeyPath[], locale?: Locales) => TransformedContent;
+declare const processDictionary: (content: Dictionary | DictionaryValue, dictionaryId: string, dictionaryPath: string, keyPath?: KeyPath[], locale?: Locales) => TransformedContent;
 
 export { processDictionary, processNode };

package/dist/cjs/server/IntlayerServerProvider.cjs

@@ -27,14 +27,13 @@ module.exports = __toCommonJS(IntlayerServerProvider_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_client = require("@intlayer/config/client");
 var import_serverContext = require('./serverContext.cjs');
-const IntlayerServerContext = (0, import_serverContext.createServerContext)(
-  (0, import_client.getConfiguration)().internationalization.defaultLocale
-);
+const { defaultLocale } = (0, import_client.getConfiguration)().internationalization;
+const IntlayerServerContext = (0, import_serverContext.createServerContext)(defaultLocale);
 const useIntlayer = () => (0, import_serverContext.getServerContext)(IntlayerServerContext);
 const locale = (0, import_serverContext.getServerContext)(IntlayerServerContext);
 const IntlayerServerProvider = ({
   children,
-  locale: locale2
+  locale: locale2 = defaultLocale
 }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(IntlayerServerContext.Provider, { value: locale2, children });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/server/IntlayerServerProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/server/IntlayerServerProvider.tsx"],"sourcesContent":["import { type Locales, getConfiguration } from '@intlayer/config/client';\nimport type { FC, PropsWithChildren } from 'react';\nimport { createServerContext, getServerContext } from './serverContext';\n\n/**\n * Context that store the current locale on the server side\n */\nexport const IntlayerServerContext = createServerContext<Locales>(\n  getConfiguration().internationalization.defaultLocale\n);\n\n/**\n * Hook that provides the current locale\n */\nexport const useIntlayer = () => getServerContext(IntlayerServerContext);\n\n/**\n * Get the current locale\n */\nexport const locale = getServerContext(IntlayerServerContext);\n\nexport type IntlayerServerProviderProps = PropsWithChildren & {\n  locale: Locales;\n};\n\n/**\n * Provider that store the current locale on the server side\n */\nexport const IntlayerServerProvider: FC<IntlayerServerProviderProps> = ({\n  children,\n  locale,\n}) => (\n  <IntlayerServerContext.Provider value={locale}>\n    {children}\n  </IntlayerServerContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCE;AAhCF,oBAA+C;AAE/C,2BAAsD;AAK/C,MAAM,4BAAwB;AAAA,MACnC,gCAAiB,EAAE,qBAAqB;AAC1C;AAKO,MAAM,cAAc,UAAM,uCAAiB,qBAAqB;AAKhE,MAAM,aAAS,uCAAiB,qBAAqB;AASrD,MAAM,yBAA0D,CAAC;AAAA,EACtE;AAAA,EACA,QAAAA;AACF,MACE,4CAAC,sBAAsB,UAAtB,EAA+B,OAAOA,SACpC,UACH;","names":["locale"]}
+{"version":3,"sources":["../../../src/server/IntlayerServerProvider.tsx"],"sourcesContent":["import { type Locales, getConfiguration } from '@intlayer/config/client';\nimport type { FC, PropsWithChildren } from 'react';\nimport { createServerContext, getServerContext } from './serverContext';\n\nconst { defaultLocale } = getConfiguration().internationalization;\n\n/**\n * Context that store the current locale on the server side\n */\nexport const IntlayerServerContext =\n  createServerContext<Locales>(defaultLocale);\n\n/**\n * Hook that provides the current locale\n */\nexport const useIntlayer = () => getServerContext(IntlayerServerContext);\n\n/**\n * Get the current locale\n */\nexport const locale = getServerContext(IntlayerServerContext);\n\nexport type IntlayerServerProviderProps = PropsWithChildren & {\n  locale?: Locales;\n};\n\n/**\n * Provider that store the current locale on the server side\n */\nexport const IntlayerServerProvider: FC<IntlayerServerProviderProps> = ({\n  children,\n  locale = defaultLocale,\n}) => (\n  <IntlayerServerContext.Provider value={locale}>\n    {children}\n  </IntlayerServerContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCE;AAjCF,oBAA+C;AAE/C,2BAAsD;AAEtD,MAAM,EAAE,cAAc,QAAI,gCAAiB,EAAE;AAKtC,MAAM,4BACX,0CAA6B,aAAa;AAKrC,MAAM,cAAc,UAAM,uCAAiB,qBAAqB;AAKhE,MAAM,aAAS,uCAAiB,qBAAqB;AASrD,MAAM,yBAA0D,CAAC;AAAA,EACtE;AAAA,EACA,QAAAA,UAAS;AACX,MACE,4CAAC,sBAAsB,UAAtB,EAA+B,OAAOA,SACpC,UACH;","names":["locale"]}

package/dist/cjs/server/IntlayerServerProvider.d.ts

@@ -1,18 +1,17 @@
-import * as react from 'react';
-import { PropsWithChildren, FC } from 'react';
 import { Locales } from '@intlayer/config/client';
+import { PropsWithChildren, FC } from 'react';
 
 /**
  * Context that store the current locale on the server side
  */
 declare const IntlayerServerContext: {
     Provider: ({ children, value, }: {
-        children: react.ReactNode;
+        children: React.ReactNode;
         value: Locales;
-    }) => react.ReactNode;
+    }) => React.ReactNode;
     Consumer: ({ children, }: {
-        children: (context: Locales | undefined) => react.ReactNode;
-    }) => react.ReactNode;
+        children: (context: Locales | undefined) => React.ReactNode;
+    }) => React.ReactNode;
     _storage: () => {
         value: Locales | undefined;
     };
@@ -27,7 +26,7 @@ declare const useIntlayer: () => Locales | undefined;
  */
 declare const locale: Locales | undefined;
 type IntlayerServerProviderProps = PropsWithChildren & {
-    locale: Locales;
+    locale?: Locales;
 };
 /**
  * Provider that store the current locale on the server side

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

@@ -6,4 +6,5 @@ import '@intlayer/config/client';
 import '@intlayer/core';
 import 'react';
 import '../useIntlayerBase.js';
+import '@intlayer/config';
 import 'intlayer';

package/dist/cjs/server/serverContext.cjs

@@ -58,8 +58,7 @@ const getServerContext = ({
   _defaultValue
 }) => {
   const store = _storage();
-  if (!store)
-    return _defaultValue;
+  if (!store) return _defaultValue;
   return store.value;
 };
 const throwInClient = () => {

package/dist/cjs/server/serverContext.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/server/serverContext.ts"],"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.Provider value={locale}>\n *      {children}\n * </IntlayerServer.Provider>\n */\n\nimport react 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  const cache = react.cache<CacheType<T>> ?? cacheFallback;\n\n  const getCache = cache(() => ({\n    value: undefined,\n  }));\n\n  return {\n    Provider: ({ children, value }) => {\n      getCache().value = value;\n      return children;\n    },\n    Consumer: ({ children }) => {\n      const store = getCache();\n      return children(store ? store.value : defaultValue);\n    },\n    _storage: getCache,\n    _defaultValue: defaultValue,\n  };\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> = {\n  Provider: ({\n    children,\n    value,\n  }: {\n    children: React.ReactNode;\n    value: T;\n  }) => React.ReactNode;\n  Consumer: ({\n    children,\n  }: {\n    children: (context: T | undefined) => React.ReactNode;\n  }) => React.ReactNode;\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 = (): void | 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,mBAAkB;AAIlB,MAAM,gBAAgB,MAAM,OAAO,EAAE,OAAO,OAAU;AAE/C,MAAM,sBAAsB,CAAI,iBAAuC;AAC5E,gBAAc;AAEd,QAAM,QAAQ,aAAAA,QAAM,SAAuB;AAE3C,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B,OAAO;AAAA,EACT,EAAE;AAEF,SAAO;AAAA,IACL,UAAU,CAAC,EAAE,UAAU,MAAM,MAAM;AACjC,eAAS,EAAE,QAAQ;AACnB,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,EAAE,SAAS,MAAM;AAC1B,YAAM,QAAQ,SAAS;AACvB,aAAO,SAAS,QAAQ,MAAM,QAAQ,YAAY;AAAA,IACpD;AAAA,IACA,UAAU;AAAA,IACV,eAAe;AAAA,EACjB;AACF;AASO,MAAM,mBAAmB,CAAI;AAAA,EAClC;AAAA,EACA;AACF,MAAwB;AAEtB,QAAM,QAAQ,SAAS;AACvB,MAAI,CAAC;AAAO,WAAO;AACnB,SAAO,MAAM;AACf;AAuBA,MAAM,gBAAgB,MAAoB;AAExC,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AACF;","names":["react"]}
+{"version":3,"sources":["../../../src/server/serverContext.ts"],"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.Provider value={locale}>\n *      {children}\n * </IntlayerServer.Provider>\n */\n\nimport react 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  const cache = react.cache<CacheType<T>> ?? cacheFallback;\n\n  const getCache = cache(() => ({\n    value: undefined,\n  }));\n\n  return {\n    Provider: ({ children, value }) => {\n      getCache().value = value;\n      return children;\n    },\n    Consumer: ({ children }) => {\n      const store = getCache();\n      return children(store ? store.value : defaultValue);\n    },\n    _storage: getCache,\n    _defaultValue: defaultValue,\n  };\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> = {\n  Provider: ({\n    children,\n    value,\n  }: {\n    children: React.ReactNode;\n    value: T;\n  }) => React.ReactNode;\n  Consumer: ({\n    children,\n  }: {\n    children: (context: T | undefined) => React.ReactNode;\n  }) => React.ReactNode;\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 = (): void | 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,mBAAkB;AAIlB,MAAM,gBAAgB,MAAM,OAAO,EAAE,OAAO,OAAU;AAE/C,MAAM,sBAAsB,CAAI,iBAAuC;AAC5E,gBAAc;AAEd,QAAM,QAAQ,aAAAA,QAAM,SAAuB;AAE3C,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B,OAAO;AAAA,EACT,EAAE;AAEF,SAAO;AAAA,IACL,UAAU,CAAC,EAAE,UAAU,MAAM,MAAM;AACjC,eAAS,EAAE,QAAQ;AACnB,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,EAAE,SAAS,MAAM;AAC1B,YAAM,QAAQ,SAAS;AACvB,aAAO,SAAS,QAAQ,MAAM,QAAQ,YAAY;AAAA,IACpD;AAAA,IACA,UAAU;AAAA,IACV,eAAe;AAAA,EACjB;AACF;AASO,MAAM,mBAAmB,CAAI;AAAA,EAClC;AAAA,EACA;AACF,MAAwB;AAEtB,QAAM,QAAQ,SAAS;AACvB,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO,MAAM;AACf;AAuBA,MAAM,gBAAgB,MAAoB;AAExC,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AACF;","names":["react"]}

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

@@ -1,6 +1,8 @@
 import { UseIntlayer } from '../useIntlayerBase.js';
-import '@intlayer/config/client';
+import '@intlayer/config';
+import '@intlayer/core';
 import 'intlayer';
+import 'react';
 
 /**
  * On the server side, Hook that picking one dictionary by its id and return the content

package/dist/cjs/useIntlayerBase.cjs

@@ -28,23 +28,48 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var useIntlayerBase_exports = {};
 __export(useIntlayerBase_exports, {
+  recursiveTransformContent: () => recursiveTransformContent,
   useIntlayerBase: () => useIntlayerBase
 });
 module.exports = __toCommonJS(useIntlayerBase_exports);
 var import_dictionaries_entry = __toESM(require("@intlayer/dictionaries-entry"));
+var import_client = require("intlayer-editor/client");
+var import_react = require("react");
 var import_processDictionary = require('./processDictionary/index.cjs');
+const recursiveTransformContent = (value) => {
+  if (typeof value === "function") {
+    return (props) => recursiveTransformContent(value(props));
+  } else if (typeof value === "object" && typeof value.keyPath !== "undefined" && typeof value.dictionaryId !== "undefined" && typeof value.dictionaryPath !== "undefined") {
+    return (0, import_client.renderIntlayerEditor)(value);
+  } else if (typeof value === "object" && Array.isArray(value)) {
+    return value.map(recursiveTransformContent);
+  } else if (typeof value === "object" && (0, import_react.isValidElement)(value)) {
+    return value;
+  } else if (typeof value === "object") {
+    return Object.entries(value).reduce(
+      (acc, [key, value2]) => ({
+        ...acc,
+        [key]: recursiveTransformContent(value2)
+      }),
+      {}
+    );
+  }
+  return value.value;
+};
 const useIntlayerBase = (id, locale) => {
   const dictionary = import_dictionaries_entry.default[id];
-  return (0, import_processDictionary.processDictionary)(
+  const result = (0, import_processDictionary.processDictionary)(
     dictionary,
     id,
     dictionary.filePath,
     [],
     locale
   );
+  return recursiveTransformContent(result);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  recursiveTransformContent,
   useIntlayerBase
 });
 //# sourceMappingURL=useIntlayerBase.cjs.map

package/dist/cjs/useIntlayerBase.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/useIntlayerBase.ts"],"sourcesContent":["import type { Locales } from '@intlayer/config/client';\n/**\n * @intlayer/dictionaries-entry is a package that only returns the dictionary entry path.\n * Using an external package allow to alias it in the bundle configuration (such as webpack).\n * The alias allow hot reload the app (such as nextjs) on any dictionary change.\n */\nimport dictionaries from '@intlayer/dictionaries-entry';\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport type { Content } from './processDictionary/contentDictionary';\nimport { processDictionary } from './processDictionary/index';\n\nexport type StringFallback<T> = T extends never ? string : T; // If no keys are found, return string to disable error, and accept any string as dictionary key\nexport type DictionaryKeys = StringFallback<\n  keyof IntlayerDictionaryTypesConnector\n>;\n\nexport type UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => IntlayerDictionaryTypesConnector[T];\n\n/**\n * Hook that picking one dictionary by its id and return the content.\n */\nexport const useIntlayerBase: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const dictionary: Content = dictionaries[id];\n\n  return processDictionary(\n    dictionary,\n    id,\n    dictionary.filePath as string,\n    [],\n    locale\n  ) as IntlayerDictionaryTypesConnector[T];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,gCAAyB;AAGzB,+BAAkC;AAe3B,MAAM,kBAA+B,CAC1C,IACA,WACG;AACH,QAAM,aAAsB,0BAAAA,QAAa,EAAE;AAE3C,aAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,CAAC;AAAA,IACD;AAAA,EACF;AACF;","names":["dictionaries"]}
+{"version":3,"sources":["../../src/useIntlayerBase.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Locales } from '@intlayer/config';\n/**\n * @intlayer/dictionaries-entry is a package that only returns the dictionary entry path.\n * Using an external package allow to alias it in the bundle configuration (such as webpack).\n * The alias allow hot reload the app (such as nextjs) on any dictionary change.\n */\nimport type { Dictionary, NodeType } from '@intlayer/core';\nimport dictionaries from '@intlayer/dictionaries-entry';\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport { renderIntlayerEditor } from 'intlayer-editor/client';\nimport { isValidElement, type ReactNode } from 'react';\nimport { processDictionary } from './processDictionary/index';\n\n/**\n * Provides a fallback to string type if the generic type T is never,\n * otherwise returns T. This is useful for handling cases where no keys are found.\n * Example: StringFallback<never> -> string; StringFallback<'key'> -> 'key'\n */\nexport type StringFallback<T> = T extends never ? string : T; // If no keys are found, return string to disable error, and accept any string as dictionary key\n\n/**\n * Represents the keys of the IntlayerDictionaryTypesConnector,\n * ensuring they are valid dictionary keys or fallback to string if none exist.\n *\n * Example:\n * ```ts\n * DictionaryKeys -> 'key1' | 'key2'\n * // or if IntlayerDictionaryTypesConnector is not defined,\n * DictionaryKeys -> string\n * ```\n */\nexport type DictionaryKeys = StringFallback<\n  keyof IntlayerDictionaryTypesConnector\n>;\n\nexport type IntlayerNode<T = string> = ReactNode & {\n  value: T;\n};\n\ntype TransformNodeType<T, L extends Locales> = T extends {\n  [NodeType.Enumeration]: { '1': any };\n}\n  ? (quantity: number) => DeepTransformContent<T[NodeType.Enumeration]['1'], L>\n  : T extends {\n        [NodeType.Translation]: object;\n      }\n    ? L extends keyof T[NodeType.Translation]\n      ? DeepTransformContent<T[NodeType.Translation][L], L> // DeepTransformContent<T[L], L>\n      : never\n    : T;\n\ntype DeepTransformContent<T, L extends Locales> = T extends object // Check if the property is an object\n  ? T extends (infer U)[] // If it's an array, infer the type of array elements\n    ? DeepTransformContent<U, L>[] // Apply DeepTransformContent recursively to each element of the array\n    : T extends {\n          nodeType: NodeType | string;\n        }\n      ? TransformNodeType<T, L>\n      : T extends { _owner: any; key: any; props: any; ref: any }\n        ? ReactNode\n        : {\n            [K in keyof T]: DeepTransformContent<T[K], L>;\n          }\n  : T extends undefined\n    ? never\n    : IntlayerNode<T>;\n\n/**\n * Excludes the 'id' and 'filePath' keys from the dictionary content,\n * as they are not part of the IntlayerDictionaryTypesConnector type.\n */\ntype ExcludeIntlayerUtilsKeys<T> = Omit<T, 'id' | 'filePath'>;\n\n/**\n * Represents the data type returned by the useIntlayer hook,\n * excluding the 'id' and 'filePath' keys from the dictionary content.\n */\ntype Data<\n  T extends DictionaryKeys,\n  K extends Locales,\n> = ExcludeIntlayerUtilsKeys<\n  DeepTransformContent<IntlayerDictionaryTypesConnector[T], K>\n>;\n\n/**\n * Parcourt the object. If a object has a keyPath, render the intlayer editor if editor enabled.\n */\nexport const recursiveTransformContent = (value: any): object => {\n  if (typeof value === 'function') {\n    return (props: any) => recursiveTransformContent(value(props));\n  } else if (\n    typeof value === 'object' &&\n    typeof value.keyPath !== 'undefined' &&\n    typeof value.dictionaryId !== 'undefined' &&\n    typeof value.dictionaryPath !== 'undefined'\n  ) {\n    return renderIntlayerEditor(value);\n  } else if (typeof value === 'object' && Array.isArray(value)) {\n    return value.map(recursiveTransformContent);\n  } else if (typeof value === 'object' && isValidElement(value)) {\n    return value;\n  } else if (typeof value === 'object') {\n    return Object.entries(value).reduce(\n      (acc, [key, value]) => ({\n        ...acc,\n        [key]: recursiveTransformContent(value),\n      }),\n      {} as object\n    );\n  }\n\n  return value.value;\n};\n\n/**\n * Type definition for the useIntlayer hook, which takes a dictionary ID and an optional locale,\n * and returns the deeply transformed dictionary content.\n *\n */\nexport type UseIntlayer = <T extends DictionaryKeys, L extends Locales>(\n  id: T,\n  locale?: L\n) => Data<T, L>;\n\n/**\n * Hook that picks one dictionary by its ID and returns the content,\n * deeply transformed according to the dictionary structure and metadata.\n */\nexport const useIntlayerBase: UseIntlayer = <\n  T extends DictionaryKeys,\n  L extends Locales,\n>(\n  id: T,\n  locale?: L\n) => {\n  const dictionary: Dictionary = dictionaries[id as keyof typeof dictionaries];\n\n  const result = processDictionary(\n    dictionary,\n    id,\n    dictionary.filePath,\n    [],\n    locale\n  ) as object;\n\n  return recursiveTransformContent(result) as Data<T, L>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,gCAAyB;AAEzB,oBAAqC;AACrC,mBAA+C;AAC/C,+BAAkC;AA4E3B,MAAM,4BAA4B,CAAC,UAAuB;AAC/D,MAAI,OAAO,UAAU,YAAY;AAC/B,WAAO,CAAC,UAAe,0BAA0B,MAAM,KAAK,CAAC;AAAA,EAC/D,WACE,OAAO,UAAU,YACjB,OAAO,MAAM,YAAY,eACzB,OAAO,MAAM,iBAAiB,eAC9B,OAAO,MAAM,mBAAmB,aAChC;AACA,eAAO,oCAAqB,KAAK;AAAA,EACnC,WAAW,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GAAG;AAC5D,WAAO,MAAM,IAAI,yBAAyB;AAAA,EAC5C,WAAW,OAAO,UAAU,gBAAY,6BAAe,KAAK,GAAG;AAC7D,WAAO;AAAA,EACT,WAAW,OAAO,UAAU,UAAU;AACpC,WAAO,OAAO,QAAQ,KAAK,EAAE;AAAA,MAC3B,CAAC,KAAK,CAAC,KAAKA,MAAK,OAAO;AAAA,QACtB,GAAG;AAAA,QACH,CAAC,GAAG,GAAG,0BAA0BA,MAAK;AAAA,MACxC;AAAA,MACA,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,MAAM;AACf;AAgBO,MAAM,kBAA+B,CAI1C,IACA,WACG;AACH,QAAM,aAAyB,0BAAAC,QAAa,EAA+B;AAE3E,QAAM,aAAS;AAAA,IACb;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,CAAC;AAAA,IACD;AAAA,EACF;AAEA,SAAO,0BAA0B,MAAM;AACzC;","names":["value","dictionaries"]}

package/dist/cjs/useIntlayerBase.d.ts

@@ -1,12 +1,70 @@
-import { Locales } from '@intlayer/config/client';
+import { Locales } from '@intlayer/config';
+import { NodeType } from '@intlayer/core';
 import { IntlayerDictionaryTypesConnector } from 'intlayer';
+import { ReactNode } from 'react';
 
+/**
+ * Provides a fallback to string type if the generic type T is never,
+ * otherwise returns T. This is useful for handling cases where no keys are found.
+ * Example: StringFallback<never> -> string; StringFallback<'key'> -> 'key'
+ */
 type StringFallback<T> = T extends never ? string : T;
+/**
+ * Represents the keys of the IntlayerDictionaryTypesConnector,
+ * ensuring they are valid dictionary keys or fallback to string if none exist.
+ *
+ * Example:
+ * ```ts
+ * DictionaryKeys -> 'key1' | 'key2'
+ * // or if IntlayerDictionaryTypesConnector is not defined,
+ * DictionaryKeys -> string
+ * ```
+ */
 type DictionaryKeys = StringFallback<keyof IntlayerDictionaryTypesConnector>;
-type UseIntlayer = <T extends DictionaryKeys>(id: T, locale?: Locales) => IntlayerDictionaryTypesConnector[T];
+type IntlayerNode<T = string> = ReactNode & {
+    value: T;
+};
+type TransformNodeType<T, L extends Locales> = T extends {
+    [NodeType.Enumeration]: {
+        '1': any;
+    };
+} ? (quantity: number) => DeepTransformContent<T[NodeType.Enumeration]['1'], L> : T extends {
+    [NodeType.Translation]: object;
+} ? L extends keyof T[NodeType.Translation] ? DeepTransformContent<T[NodeType.Translation][L], L> : never : T;
+type DeepTransformContent<T, L extends Locales> = T extends object ? T extends (infer U)[] ? DeepTransformContent<U, L>[] : T extends {
+    nodeType: NodeType | string;
+} ? TransformNodeType<T, L> : T extends {
+    _owner: any;
+    key: any;
+    props: any;
+    ref: any;
+} ? ReactNode : {
+    [K in keyof T]: DeepTransformContent<T[K], L>;
+} : T extends undefined ? never : IntlayerNode<T>;
+/**
+ * Excludes the 'id' and 'filePath' keys from the dictionary content,
+ * as they are not part of the IntlayerDictionaryTypesConnector type.
+ */
+type ExcludeIntlayerUtilsKeys<T> = Omit<T, 'id' | 'filePath'>;
+/**
+ * Represents the data type returned by the useIntlayer hook,
+ * excluding the 'id' and 'filePath' keys from the dictionary content.
+ */
+type Data<T extends DictionaryKeys, K extends Locales> = ExcludeIntlayerUtilsKeys<DeepTransformContent<IntlayerDictionaryTypesConnector[T], K>>;
+/**
+ * Parcourt the object. If a object has a keyPath, render the intlayer editor if editor enabled.
+ */
+declare const recursiveTransformContent: (value: any) => object;
+/**
+ * Type definition for the useIntlayer hook, which takes a dictionary ID and an optional locale,
+ * and returns the deeply transformed dictionary content.
+ *
+ */
+type UseIntlayer = <T extends DictionaryKeys, L extends Locales>(id: T, locale?: L) => Data<T, L>;
 /**
- * Hook that picking one dictionary by its id and return the content.
+ * Hook that picks one dictionary by its ID and returns the content,
+ * deeply transformed according to the dictionary structure and metadata.
  */
 declare const useIntlayerBase: UseIntlayer;
 
-export { type DictionaryKeys, type StringFallback, type UseIntlayer, useIntlayerBase };
+export { type DictionaryKeys, type IntlayerNode, type StringFallback, type UseIntlayer, recursiveTransformContent, useIntlayerBase };

package/dist/esm/{chunk-ZNCO4QRF.mjs → chunk-ZD7AOCMD.mjs}

@@ -6,4 +6,4 @@ var __commonJS = (cb, mod) => function __require() {
 export {
   __commonJS
 };
-//# sourceMappingURL=chunk-ZNCO4QRF.mjs.map
+//# sourceMappingURL=chunk-ZD7AOCMD.mjs.map

package/dist/esm/client/ContentEditionLayout.mjs

@@ -1,4 +1,4 @@
-import "../chunk-ZNCO4QRF.mjs";
+import "../chunk-ZD7AOCMD.mjs";
 import { Fragment, jsx } from "react/jsx-runtime";
 import {
   ContentEditionLayout as ContentEditionLayoutBase

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/client/ContentEditionLayout.tsx"],"sourcesContent":["import {\n  ContentEditionLayout as ContentEditionLayoutBase,\n  type ContentEditionLayoutProps,\n} from 'intlayer-editor/client';\nimport type { FC } from 'react';\n\nconst BlankLayout: FC<ContentEditionLayoutProps> = ({ children }) => (\n  <>{children}</>\n);\n\n// intlayer-editor is an optional dependency. If it's not installed, return the blank layout\nexport const ContentEditionLayout: FC<ContentEditionLayoutProps> =\n  typeof ContentEditionLayoutBase === 'undefined'\n    ? BlankLayout\n    : (ContentEditionLayoutBase as typeof ContentEditionLayout);\n"],"mappings":";AAOE;AAPF;AAAA,EACE,wBAAwB;AAAA,OAEnB;AAGP,MAAM,cAA6C,CAAC,EAAE,SAAS,MAC7D,gCAAG,UAAS;AAIP,MAAM,uBACX,OAAO,6BAA6B,cAChC,cACC;","names":[]}
+{"version":3,"sources":["../../../src/client/ContentEditionLayout.tsx"],"sourcesContent":["import {\n  ContentEditionLayout as ContentEditionLayoutBase,\n  type ContentEditionLayoutProps,\n} from 'intlayer-editor/client';\nimport type { FC } from 'react';\n\nconst BlankLayout: FC<ContentEditionLayoutProps> = ({ children }) => (\n  <>{children}</>\n);\n\n// intlayer-editor is an optional dependency. If it's not installed, return the blank layout\nexport const ContentEditionLayout: FC<ContentEditionLayoutProps> =\n  typeof ContentEditionLayoutBase === 'undefined'\n    ? BlankLayout\n    : ContentEditionLayoutBase;\n"],"mappings":";AAOE;AAPF;AAAA,EACE,wBAAwB;AAAA,OAEnB;AAGP,MAAM,cAA6C,CAAC,EAAE,SAAS,MAC7D,gCAAG,UAAS;AAIP,MAAM,uBACX,OAAO,6BAA6B,cAChC,cACA;","names":[]}

package/dist/esm/client/{IntlayerClientProvider.d.mts → IntlayerProvider.d.mts}

@@ -14,12 +14,14 @@ declare const IntlayerClientContext: react.Context<IntlayerValue>;
  * Hook that provides the current locale
  */
 declare const useIntlayerContext: () => IntlayerValue;
-type IntlayerClientProviderProps = PropsWithChildren & {
+type IntlayerProviderProps = PropsWithChildren & {
     locale?: Locales;
+    setLocale?: (locale: Locales) => void;
+    editorEnabled?: boolean;
 };
 /**
  * Provider that store the current locale on the client side
  */
-declare const IntlayerClientProvider: FC<IntlayerClientProviderProps>;
+declare const IntlayerProvider: FC<IntlayerProviderProps>;
 
-export { IntlayerClientContext, IntlayerClientProvider, type IntlayerClientProviderProps, useIntlayerContext };
+export { IntlayerClientContext, IntlayerProvider, type IntlayerProviderProps, useIntlayerContext };

package/dist/esm/client/{IntlayerClientProvider.mjs → IntlayerProvider.mjs}

@@ -1,5 +1,5 @@
 "use client";
-import "../chunk-ZNCO4QRF.mjs";
+import "../chunk-ZD7AOCMD.mjs";
 import { jsx } from "react/jsx-runtime";
 import { getConfiguration } from "@intlayer/config/client";
 import {
@@ -16,18 +16,19 @@ const IntlayerClientContext = createContext({
   setLocale: () => null
 });
 const useIntlayerContext = () => useContext(IntlayerClientContext);
-const IntlayerClientProvider = ({
+const IntlayerProvider = ({
   locale,
-  children
+  children,
+  setLocale: setLocaleProp,
+  editorEnabled
 }) => {
   const { defaultLocale, locales: availableLocales } = getConfiguration().internationalization;
   const [currentLocale, setCurrentLocale] = useState(
     locale ?? localeCookie ?? defaultLocale
   );
-  const setLocale = useCallback(
+  const setLocaleBase = useCallback(
     (newLocale) => {
-      if (currentLocale.toString() === newLocale.toString())
-        return;
+      if (currentLocale.toString() === newLocale.toString()) return;
       if (!availableLocales.includes(newLocale)) {
         console.error(`Locale ${locale} is not available`);
         return;
@@ -37,6 +38,7 @@ const IntlayerClientProvider = ({
     },
     [availableLocales, currentLocale, locale]
   );
+  const setLocale = setLocaleProp ?? setLocaleBase;
   const value = useMemo(
     () => ({ locale: currentLocale, setLocale }),
     [currentLocale, setLocale]
@@ -47,13 +49,14 @@ const IntlayerClientProvider = ({
       locale: currentLocale,
       setLocale,
       localeList: availableLocales,
+      editorEnabled,
       children
     }
   ) });
 };
 export {
   IntlayerClientContext,
-  IntlayerClientProvider,
+  IntlayerProvider,
   useIntlayerContext
 };
-//# sourceMappingURL=IntlayerClientProvider.mjs.map
+//# sourceMappingURL=IntlayerProvider.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/IntlayerProvider.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 { ContentEditionLayout } from './ContentEditionLayout';\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 IntlayerProviderProps = PropsWithChildren & {\n  locale?: Locales;\n  setLocale?: (locale: Locales) => void;\n  editorEnabled?: boolean;\n};\n\n/**\n * Provider that store the current locale on the client side\n */\nexport const IntlayerProvider: FC<IntlayerProviderProps> = ({\n  locale,\n  children,\n  setLocale: setLocaleProp,\n  editorEnabled,\n}) => {\n  const { defaultLocale, locales: availableLocales } =\n    getConfiguration().internationalization;\n\n  const [currentLocale, setCurrentLocale] = useState(\n    locale ?? localeCookie ?? defaultLocale\n  );\n\n  const setLocaleBase = 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 setLocale = setLocaleProp ?? setLocaleBase;\n\n  const value: IntlayerValue = useMemo<IntlayerValue>(\n    () => ({ locale: currentLocale, setLocale: setLocale }),\n    [currentLocale, setLocale]\n  );\n\n  return (\n    <IntlayerClientContext.Provider value={value}>\n      <ContentEditionLayout\n        locale={currentLocale}\n        setLocale={setLocale}\n        localeList={availableLocales}\n        editorEnabled={editorEnabled}\n      >\n        {children}\n      </ContentEditionLayout>\n    </IntlayerClientContext.Provider>\n  );\n};\n"],"mappings":";;AA+EM;AA7EN,SAAS,wBAAsC;AAC/C;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AACP,SAAS,4BAA4B;AACrC,SAAS,cAAc,uBAAuB;AAUvC,MAAM,wBAAwB,cAA6B;AAAA,EAChE,QAAQ,gBAAgB,iBAAiB,EAAE,qBAAqB;AAAA,EAChE,WAAW,MAAM;AACnB,CAAC;AAKM,MAAM,qBAAqB,MAAM,WAAW,qBAAqB;AAWjE,MAAM,mBAA8C,CAAC;AAAA,EAC1D;AAAA,EACA;AAAA,EACA,WAAW;AAAA,EACX;AACF,MAAM;AACJ,QAAM,EAAE,eAAe,SAAS,iBAAiB,IAC/C,iBAAiB,EAAE;AAErB,QAAM,CAAC,eAAe,gBAAgB,IAAI;AAAA,IACxC,UAAU,gBAAgB;AAAA,EAC5B;AAEA,QAAM,gBAAgB;AAAA,IACpB,CAAC,cAAuB;AACtB,UAAI,cAAc,SAAS,MAAM,UAAU,SAAS,EAAG;AAEvD,UAAI,CAAC,iBAAiB,SAAS,SAAS,GAAG;AACzC,gBAAQ,MAAM,UAAU,MAAM,mBAAmB;AACjD;AAAA,MACF;AAEA,uBAAiB,SAAS;AAC1B,sBAAgB,SAAS;AAAA,IAC3B;AAAA,IACA,CAAC,kBAAkB,eAAe,MAAM;AAAA,EAC1C;AAEA,QAAM,YAAY,iBAAiB;AAEnC,QAAM,QAAuB;AAAA,IAC3B,OAAO,EAAE,QAAQ,eAAe,UAAqB;AAAA,IACrD,CAAC,eAAe,SAAS;AAAA,EAC3B;AAEA,SACE,oBAAC,sBAAsB,UAAtB,EAA+B,OAC9B;AAAA,IAAC;AAAA;AAAA,MACC,QAAQ;AAAA,MACR;AAAA,MACA,YAAY;AAAA,MACZ;AAAA,MAEC;AAAA;AAAA,EACH,GACF;AAEJ;","names":[]}