react-intlayer 1.2.0 → 2.0.0

package/src/processDictionary/index.ts

@@ -1,13 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  type Locales,
-  intlayerIntlConfiguration,
-} from '@intlayer/config/client';
+import { type Locales, getConfiguration } from '@intlayer/config/client';
 import {
   NodeType,
   type QuantityContent,
   type LanguageContent,
+  findMatchingCondition,
+  type KeyPath,
 } from '@intlayer/core';
+import { renderContentEditor } from 'intlayer-editor/client';
+import { type ReactElement, createElement, type ReactNode } from 'react';
 import { getEnumeration } from '../getEnumeration';
 import { getTranslation } from '../getTranslation';
 import type {
@@ -17,23 +18,42 @@ import type {
   TransformedContentValue,
 } from './contentDictionary';
 
-const defaultLocale = intlayerIntlConfiguration.defaultLocale;
+const {
+  internationalization: { defaultLocale },
+} = getConfiguration();
 
 const processTranslation = (
   languageContent: LanguageContent<ContentValue>,
-  locale: Locales
+  locale: Locales,
+  dictionaryId: string,
+  dictionaryPath: string,
+  keyPath: KeyPath[] = []
 ): TransformedContent => {
   const translationResult: ContentValue = getTranslation<ContentValue>(
     languageContent,
     locale
   );
 
-  return processDictionary(translationResult as Content, locale);
+  const resultKeyPath: KeyPath[] = [
+    ...keyPath,
+    { type: NodeType.Translation, key: locale },
+  ];
+
+  return processDictionary(
+    translationResult as Content,
+    dictionaryId,
+    dictionaryPath,
+    resultKeyPath,
+    locale
+  );
 };
 
 const processEnumeration = (
   enumerationContent: QuantityContent<ContentValue>,
-  locale: Locales
+  locale: Locales,
+  dictionaryId: string,
+  dictionaryPath: string,
+  keyPath: KeyPath[] = []
 ): TransformedContentValue => {
   return (quantity: number): TransformedContentValue => {
     const enumerationResult: ContentValue = getEnumeration<ContentValue>(
@@ -41,44 +61,126 @@ const processEnumeration = (
       quantity
     );
 
+    const matchingCondition = findMatchingCondition(
+      enumerationContent,
+      quantity
+    );
+
+    const resultKeyPath: KeyPath[] = [
+      ...keyPath,
+      { type: NodeType.Enumeration, key: matchingCondition.toString() },
+    ];
+
     //
-    return processDictionary(enumerationResult as Content, locale);
+    return processDictionary(
+      enumerationResult as Content,
+      dictionaryId,
+      dictionaryPath,
+      resultKeyPath,
+      locale
+    );
   };
 };
 
+const isReactNode = (node: Record<string, unknown>): boolean =>
+  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';
+
 export const processNode = (
   field: ContentValue | undefined,
-  locale: Locales
+  locale: Locales,
+  dictionaryId: string,
+  dictionaryPath: string,
+  keyPath: KeyPath[] = []
 ): TransformedContentValue => {
-  if (typeof field !== 'object' || field === null) {
-    return field;
-  }
+  if (typeof field === 'object') {
+    if (field.nodeType === NodeType.Translation) {
+      return processTranslation(
+        field as LanguageContent<ContentValue>,
+        locale,
+        dictionaryId,
+        dictionaryPath,
+        keyPath
+      );
+    }
 
-  if (field.nodeType === NodeType.Translation) {
-    return processTranslation(field as LanguageContent<ContentValue>, locale);
+    if (field.nodeType === NodeType.Enumeration) {
+      return processEnumeration(
+        field satisfies QuantityContent<ContentValue>,
+        locale,
+        dictionaryId,
+        dictionaryPath,
+        keyPath
+      );
+    }
   }
 
-  if (field.nodeType === NodeType.Enumeration) {
-    return processEnumeration(
-      field satisfies QuantityContent<ContentValue>,
-      locale
-    );
-  }
+  return processDictionary(
+    field as Content,
+    dictionaryId,
+    dictionaryPath,
+    keyPath,
+    locale
+  );
+};
 
-  if (typeof (field as any).type === 'undefined') {
-    return processDictionary(field as Content, locale);
+// This function recursively creates React elements from a given JSON-like structure
+const createReactElement = (element: ReactElement) => {
+  if (typeof element === 'string') {
+    // If it's a string, simply return it (used for text content)
+    return element;
   }
 
-  return field as TransformedContentValue;
+  // Destructure the component properties
+
+  const convertChildrenAsArray = (element: ReactElement): ReactElement => {
+    if (element?.props && typeof element.props.children === 'object') {
+      const childrenResult: ReactNode[] = [];
+      const { children } = element.props;
+
+      // Create the children elements recursively, if any
+      Object.keys(children).forEach((key) => {
+        childrenResult.push(createReactElement(children[key]));
+      });
+
+      return {
+        ...element,
+        props: { ...element.props, children: childrenResult },
+      };
+    }
+
+    return {
+      ...element,
+      props: { ...element.props, children: element.props.children },
+    };
+  };
+
+  const fixedElement = convertChildrenAsArray(element);
+
+  const { type, props } = fixedElement;
+
+  // Create and return the React element
+  return createElement(type ?? 'div', props, ...props.children);
 };
 
+const traceKeys: string[] = ['filePath', 'id', 'nodeType'];
+
 /**
  * Function that process a dictionary and return the result to be used in the application.
  */
 export const processDictionary = (
   content: Content,
+  dictionaryId: string,
+  dictionaryPath: string,
+  keyPath: KeyPath[] = [],
   locale: Locales = defaultLocale
 ): TransformedContent => {
+  // If it's a React element, render it
+  if (isReactNode(content)) {
+    return createReactElement(
+      content as unknown as ReactElement
+    ) as unknown as TransformedContent;
+  }
+
   if (content && typeof content === 'object') {
     const result: TransformedContent = {};
 
@@ -86,12 +188,44 @@ export const processDictionary = (
     for (const key of Object.keys(content)) {
       const field = content[key];
 
-      result[key] = processNode(field, locale);
+      if (traceKeys.includes(key)) {
+        result[key] = field as TransformedContentValue;
+        continue;
+      }
+
+      const resultKeyPath: KeyPath[] = [
+        ...keyPath,
+        { type: 'ObjectExpression', key },
+      ];
+
+      result[key] = processNode(
+        field,
+        locale,
+        dictionaryId,
+        dictionaryPath,
+        resultKeyPath
+      );
     }
 
     return result;
   }
 
+  if (typeof content === 'string') {
+    try {
+      // renderContentEditor come from intlayer-editor, which is an optional dependency.
+      // intlayer-editor should be installed in the project to use the content editor.
+      return renderContentEditor(
+        content,
+        dictionaryId,
+        dictionaryPath,
+        keyPath
+      );
+    } catch (e) {
+      // If renderContentEditor not available, it will return the content as is.
+      return content;
+    }
+  }
+
   // If it's a string, number, or function, return it
   return content;
 };

package/src/server/IntlayerServerProvider.tsx

@@ -1,7 +1,4 @@
-import {
-  type Locales,
-  intlayerIntlConfiguration,
-} from '@intlayer/config/client';
+import { type Locales, getConfiguration } from '@intlayer/config/client';
 import type { FC, PropsWithChildren } from 'react';
 import { createServerContext, getServerContext } from './serverContext';
 
@@ -9,7 +6,7 @@ import { createServerContext, getServerContext } from './serverContext';
  * Context that store the current locale on the server side
  */
 export const IntlayerServerContext = createServerContext<Locales>(
-  intlayerIntlConfiguration.defaultLocale
+  getConfiguration().internationalization.defaultLocale
 );
 
 /**

package/src/server/getLocaleTranslation.ts

@@ -1,4 +1,4 @@
-import { intlayerIntlConfiguration } from '@intlayer/config/client';
+import { getConfiguration } from '@intlayer/config/client';
 import { type LanguageContent, getTranslationContent } from '@intlayer/core';
 import { IntlayerServerContext } from './IntlayerServerProvider';
 import { getServerContext } from './serverContext';
@@ -12,7 +12,7 @@ export const getLocaleTranslation = <Content>(
   const locale = getServerContext(IntlayerServerContext);
   const content = getTranslationContent<Content>(
     languageContent,
-    locale ?? intlayerIntlConfiguration.defaultLocale
+    locale ?? getConfiguration().internationalization.defaultLocale
   );
 
   return {

package/src/server/useTraduction.ts

@@ -13,12 +13,13 @@ import { getServerContext } from './serverContext';
  *
  * Usage:
  *
- * const content = getTranslation<string>({
+ * ```ts
+ * const content = useTraduction<string>({
  * en: 'Hello',
  * fr: 'Bonjour',
- * },
- * 'fr');
+ * }, 'fr');
  * // 'Bonjour'
+ * ```
  *
  * Using TypeScript:
  * - this function will require each locale to be defined if defined in the project configuration.

package/src/useIntlayerBase.ts

@@ -30,6 +30,9 @@ export const useIntlayerBase: UseIntlayer = <T extends DictionaryKeys>(
 
   return processDictionary(
     dictionary,
+    id,
+    dictionary.filePath as string,
+    [],
     locale
   ) as IntlayerDictionaryTypesConnector[T];
 };

package/src/vite/intlayerPlugin.ts

@@ -0,0 +1,59 @@
+import { join, relative, resolve } from 'path';
+import { watch } from '@intlayer/chokidar';
+import { getConfiguration, formatEnvVariable } from '@intlayer/config';
+import { loadEnv, type Plugin } from 'vite';
+
+// Plugin options type definition
+type PluginOptions = {
+  // Custom options for your plugin, if any
+};
+
+/**
+ *
+ * A Vite plugin that integrates IntLayer configuration into the build process
+ *
+ * ```ts
+ * // Example usage of the plugin in a Vite configuration
+ * export default defineConfig({
+ *   plugins: [ intLayerPlugin() ],
+ * });
+ * ```
+ *  */
+export const intLayerPlugin = (_pluginOptions: PluginOptions = {}): Plugin => ({
+  name: 'vite-intlayer-plugin',
+
+  config: (config, { mode }) => {
+    const intlayerConfig = getConfiguration();
+
+    // Set all configuration values as environment variables
+    const env = formatEnvVariable('vite');
+
+    process.env = { ...process.env, ...loadEnv(mode, process.cwd()), ...env };
+
+    const { mainDir, baseDir } = intlayerConfig.content;
+    const dictionariesPath = join(mainDir, 'dictionaries.mjs');
+    const relativeDictionariesPath = relative(baseDir, dictionariesPath);
+
+    // Update Vite's resolve alias
+    config.resolve = {
+      ...config.resolve,
+      alias: {
+        ...config.resolve?.alias,
+        '@intlayer/dictionaries-entry': resolve(relativeDictionariesPath),
+      },
+    };
+
+    return config;
+  },
+
+  buildStart: () => {
+    // Code to run when Vite build starts
+    watch({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      persistent: (import.meta as any).env === 'development',
+    });
+  },
+  configureServer: () => {
+    // Custom server configuration, if needed
+  },
+});

package/dist/cjs/ContentEditor/ContentEditor.cjs

@@ -1,110 +0,0 @@
-"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 ContentEditor_exports = {};
-__export(ContentEditor_exports, {
-  ContentEditor: () => ContentEditor
-});
-module.exports = __toCommonJS(ContentEditor_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_react = require("react");
-const PRESS_DETECT_DURATION = 500;
-const ContentEditor = ({ children }) => {
-  const divRef = (0, import_react.useRef)(null);
-  const [isEditing, setIsEditing] = (0, import_react.useState)(false);
-  const pressTimerRef = (0, import_react.useRef)(null);
-  const handleOnLongPress = () => {
-    setIsEditing(true);
-  };
-  const startPressTimer = () => {
-    pressTimerRef.current = setTimeout(() => {
-      handleOnLongPress();
-    }, PRESS_DETECT_DURATION);
-  };
-  const clearPressTimer = () => {
-    if (pressTimerRef.current) {
-      clearTimeout(pressTimerRef.current);
-      pressTimerRef.current = null;
-    }
-  };
-  const handleMouseDown = () => {
-    clearPressTimer();
-    startPressTimer();
-  };
-  const handleMouseUp = () => {
-    clearPressTimer();
-  };
-  const handleClickOutside = (0, import_react.useCallback)(
-    (event) => {
-      if (divRef.current && !divRef.current.contains(event.target)) {
-        setIsEditing(false);
-      }
-    },
-    [divRef]
-  );
-  (0, import_react.useEffect)(() => {
-    document.addEventListener("mousedown", handleClickOutside);
-    return () => {
-      document.removeEventListener("mousedown", handleClickOutside);
-      clearPressTimer();
-    };
-  }, [handleClickOutside]);
-  const handleOnClick = (e) => {
-    if (isEditing) {
-      e.preventDefault();
-      e.stopPropagation();
-    }
-  };
-  const handleOnBlur = () => {
-    setIsEditing(false);
-  };
-  const onContentChange = (_e) => {
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    "div",
-    {
-      role: "textbox",
-      tabIndex: 0,
-      onKeyUp: () => null,
-      contentEditable: isEditing,
-      onInput: onContentChange,
-      onClick: handleOnClick,
-      onMouseDown: handleMouseDown,
-      onMouseUp: handleMouseUp,
-      onMouseLeave: handleMouseUp,
-      onTouchStart: handleMouseDown,
-      onTouchEnd: handleMouseUp,
-      onTouchCancel: handleMouseUp,
-      onBlur: handleOnBlur,
-      suppressContentEditableWarning: true,
-      style: isEditing ? {
-        backgroundColor: "transparent",
-        cursor: "text",
-        display: "inline"
-      } : { cursor: "pointer", display: "inline" },
-      ref: divRef,
-      children
-    }
-  );
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ContentEditor
-});
-//# sourceMappingURL=ContentEditor.cjs.map

package/dist/cjs/ContentEditor/ContentEditor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/ContentEditor/ContentEditor.tsx"],"sourcesContent":["'use client';\n\nimport {\n  useEffect,\n  useState,\n  useRef,\n  useCallback,\n  type FC,\n  type MouseEventHandler,\n} from 'react';\n\ntype ContentEditorProps = {\n  children?: string;\n};\n\nconst PRESS_DETECT_DURATION = 500;\n\nexport const ContentEditor: FC<ContentEditorProps> = ({ children }) => {\n  const divRef = useRef<HTMLDivElement>(null);\n  const [isEditing, setIsEditing] = useState(false);\n  const pressTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  const handleOnLongPress = () => {\n    setIsEditing(true);\n  };\n\n  const startPressTimer = () => {\n    pressTimerRef.current = setTimeout(() => {\n      handleOnLongPress();\n    }, PRESS_DETECT_DURATION);\n  };\n\n  const clearPressTimer = () => {\n    if (pressTimerRef.current) {\n      clearTimeout(pressTimerRef.current);\n      pressTimerRef.current = null;\n    }\n  };\n\n  const handleMouseDown = () => {\n    clearPressTimer(); // Ensure any previous timer is cleared\n    startPressTimer();\n  };\n\n  const handleMouseUp = () => {\n    clearPressTimer();\n  };\n\n  // Use useCallback to ensure the function identity remains stable\n  const handleClickOutside = useCallback(\n    (event: MouseEvent) => {\n      if (divRef.current && !divRef.current.contains(event.target as Node)) {\n        setIsEditing(false);\n      }\n    },\n    [divRef]\n  );\n\n  useEffect(() => {\n    // Attach click outside listener\n    document.addEventListener('mousedown', handleClickOutside);\n\n    return () => {\n      // Cleanup\n      document.removeEventListener('mousedown', handleClickOutside);\n      clearPressTimer(); // Ensure to clear the timer when component unmounts\n    };\n  }, [handleClickOutside]);\n\n  const handleOnClick: MouseEventHandler<HTMLDivElement> = (e) => {\n    if (isEditing) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  };\n\n  const handleOnBlur = () => {\n    // Stop editing when the element loses focus\n    setIsEditing(false);\n  };\n\n  const onContentChange = (_e: React.FormEvent<HTMLDivElement>) => {\n    // console.log(e.currentTarget.textContent);\n  };\n\n  return (\n    <div\n      role=\"textbox\"\n      tabIndex={0}\n      onKeyUp={() => null}\n      contentEditable={isEditing}\n      onInput={onContentChange}\n      onClick={handleOnClick}\n      onMouseDown={handleMouseDown}\n      onMouseUp={handleMouseUp}\n      onMouseLeave={handleMouseUp}\n      onTouchStart={handleMouseDown}\n      onTouchEnd={handleMouseUp}\n      onTouchCancel={handleMouseUp}\n      onBlur={handleOnBlur}\n      suppressContentEditableWarning={true} // To suppress the warning for controlled components\n      style={\n        isEditing\n          ? {\n              backgroundColor: 'transparent',\n              cursor: 'text',\n              display: 'inline',\n            }\n          : { cursor: 'pointer', display: 'inline' }\n      }\n      ref={divRef}\n    >\n      {children}\n    </div>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsFI;AApFJ,mBAOO;AAMP,MAAM,wBAAwB;AAEvB,MAAM,gBAAwC,CAAC,EAAE,SAAS,MAAM;AACrE,QAAM,aAAS,qBAAuB,IAAI;AAC1C,QAAM,CAAC,WAAW,YAAY,QAAI,uBAAS,KAAK;AAChD,QAAM,oBAAgB,qBAA6C,IAAI;AAEvE,QAAM,oBAAoB,MAAM;AAC9B,iBAAa,IAAI;AAAA,EACnB;AAEA,QAAM,kBAAkB,MAAM;AAC5B,kBAAc,UAAU,WAAW,MAAM;AACvC,wBAAkB;AAAA,IACpB,GAAG,qBAAqB;AAAA,EAC1B;AAEA,QAAM,kBAAkB,MAAM;AAC5B,QAAI,cAAc,SAAS;AACzB,mBAAa,cAAc,OAAO;AAClC,oBAAc,UAAU;AAAA,IAC1B;AAAA,EACF;AAEA,QAAM,kBAAkB,MAAM;AAC5B,oBAAgB;AAChB,oBAAgB;AAAA,EAClB;AAEA,QAAM,gBAAgB,MAAM;AAC1B,oBAAgB;AAAA,EAClB;AAGA,QAAM,yBAAqB;AAAA,IACzB,CAAC,UAAsB;AACrB,UAAI,OAAO,WAAW,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAc,GAAG;AACpE,qBAAa,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,IACA,CAAC,MAAM;AAAA,EACT;AAEA,8BAAU,MAAM;AAEd,aAAS,iBAAiB,aAAa,kBAAkB;AAEzD,WAAO,MAAM;AAEX,eAAS,oBAAoB,aAAa,kBAAkB;AAC5D,sBAAgB;AAAA,IAClB;AAAA,EACF,GAAG,CAAC,kBAAkB,CAAC;AAEvB,QAAM,gBAAmD,CAAC,MAAM;AAC9D,QAAI,WAAW;AACb,QAAE,eAAe;AACjB,QAAE,gBAAgB;AAAA,IACpB;AAAA,EACF;AAEA,QAAM,eAAe,MAAM;AAEzB,iBAAa,KAAK;AAAA,EACpB;AAEA,QAAM,kBAAkB,CAAC,OAAwC;AAAA,EAEjE;AAEA,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,UAAU;AAAA,MACV,SAAS,MAAM;AAAA,MACf,iBAAiB;AAAA,MACjB,SAAS;AAAA,MACT,SAAS;AAAA,MACT,aAAa;AAAA,MACb,WAAW;AAAA,MACX,cAAc;AAAA,MACd,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,eAAe;AAAA,MACf,QAAQ;AAAA,MACR,gCAAgC;AAAA,MAChC,OACE,YACI;AAAA,QACE,iBAAiB;AAAA,QACjB,QAAQ;AAAA,QACR,SAAS;AAAA,MACX,IACA,EAAE,QAAQ,WAAW,SAAS,SAAS;AAAA,MAE7C,KAAK;AAAA,MAEJ;AAAA;AAAA,EACH;AAEJ;","names":[]}

package/dist/cjs/ContentEditor/ContentEditor.d.ts

@@ -1,8 +0,0 @@
-import { FC } from 'react';
-
-type ContentEditorProps = {
-    children?: string;
-};
-declare const ContentEditor: FC<ContentEditorProps>;
-
-export { ContentEditor };

package/dist/cjs/ContentEditor/contentRender.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/ContentEditor/contentRender.tsx"],"sourcesContent":["import { ContentEditor } from './ContentEditor';\n\nexport const contentRender = (content: string) => {\n  const isEditable = process.env.NODE_ENV === 'development';\n\n  if (isEditable && ContentEditor) {\n    return (<ContentEditor>{content}</ContentEditor>) as unknown as string;\n  }\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMY;AANZ,2BAA8B;AAEvB,MAAM,gBAAgB,CAAC,YAAoB;AAChD,QAAM,aAAa,QAAQ,IAAI,aAAa;AAE5C,MAAI,cAAc,oCAAe;AAC/B,WAAQ,4CAAC,sCAAe,mBAAQ;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/ContentEditor/contentRender.d.ts

@@ -1,3 +0,0 @@
-declare const contentRender: (content: string) => string;
-
-export { contentRender };

package/dist/cjs/ContentEditor/index.cjs

@@ -1,25 +0,0 @@
-"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ContentEditor_exports = {};
-module.exports = __toCommonJS(ContentEditor_exports);
-__reExport(ContentEditor_exports, require('./ContentEditor.cjs'), module.exports);
-__reExport(ContentEditor_exports, require('./contentRender.cjs'), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require('./ContentEditor.cjs'),
-  ...require('./contentRender.cjs')
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/ContentEditor/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/ContentEditor/index.tsx"],"sourcesContent":["export * from './ContentEditor';\nexport * from './contentRender';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,kCAAc,4BAAd;AACA,kCAAc,4BADd;","names":[]}

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

@@ -1,3 +0,0 @@
-export { ContentEditor } from './ContentEditor.js';
-export { contentRender } from './contentRender.js';
-import 'react';

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

@@ -1 +0,0 @@
-{"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

@@ -1,29 +0,0 @@
-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/esm/ContentEditor/ContentEditor.d.mts

@@ -1,8 +0,0 @@
-import { FC } from 'react';
-
-type ContentEditorProps = {
-    children?: string;
-};
-declare const ContentEditor: FC<ContentEditorProps>;
-
-export { ContentEditor };