react-intlayer 1.0.1 → 1.2.1

package/src/client/useTraduction.ts

@@ -1,12 +1,33 @@
 import type { LanguageContent } from '@intlayer/core';
 import { useContext } from 'react';
 import { getTranslation } from '../getTranslation';
-import { LocaleClientContext } from './LocaleClientContextProvider';
+import { IntlayerClientContext } from './IntlayerClientProvider';
 
-export const useTraduction = <Content>(
+/**
+ * On the client side, Hook that picking one dictionary by its id and return the content.
+ *
+ * If not locale found, it will return the content related to the default locale.
+ *
+ * Return either the content editor, or the content itself depending on the configuration.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * const content = useTraduction<string>({
+ *  en: 'Hello',
+ *  fr: 'Bonjour',
+ * }, 'fr');
+ * // 'Bonjour'
+ * ```
+ *
+ * Using TypeScript:
+ * - this function will require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+export const useTraduction = <Content = string>(
   languageContent: LanguageContent<Content>
 ): Content => {
-  const { locale } = useContext(LocaleClientContext);
+  const { locale } = useContext(IntlayerClientContext);
 
   return getTranslation(languageContent, locale);
 };

package/src/craco/craco.config.ts

@@ -0,0 +1,11 @@
+import type { CracoConfig } from '@craco/types';
+import * as intlayerPlugin from './intlayerCracoPlugin';
+
+// Usage Example
+module.exports = {
+  plugins: [
+    {
+      plugin: intlayerPlugin,
+    },
+  ],
+} satisfies CracoConfig;

package/src/craco/intlayerCracoPlugin.ts

@@ -0,0 +1,89 @@
+import { resolve, relative, join } from 'path';
+import type {
+  CracoConfig,
+  CracoConfigOverride,
+  CracoPlugin,
+  WebpackConfigOverride,
+} from '@craco/types';
+import { getConfiguration, formatEnvVariable } from '@intlayer/config';
+import { IntLayerPlugin as IntLayerWebpackPlugin } from '@intlayer/webpack';
+import webpack, { type Configuration as WebpackConfig } from 'webpack';
+
+// Get IntLayer configuration
+const intlayerConfig = getConfiguration();
+
+// Format environment variables
+const env: Record<string, string> = formatEnvVariable('react_app');
+
+// Custom CRACO plugin function to override webpack configuration
+export const overrideWebpackConfig = ({
+  webpackConfig,
+}: WebpackConfigOverride): WebpackConfig => {
+  webpackConfig.externals = {
+    ...(typeof webpackConfig.externals === 'object'
+      ? webpackConfig.externals
+      : {}),
+    esbuild: 'esbuild',
+    module: 'module',
+    fs: 'fs',
+    vm: 'vm',
+  };
+
+  (webpackConfig.module?.rules ?? []).push({
+    test: /\.node$/,
+    use: 'node-loader',
+  });
+
+  // You can add any custom CRACO plugins here if needed
+  // config.plugins.push(new CustomCracoPlugin());
+
+  return webpackConfig;
+};
+
+// Return a CRACO configuration object
+export const overrideCracoConfig = ({
+  cracoConfig,
+}: CracoConfigOverride): CracoConfig => {
+  const { mainDir, baseDir } = intlayerConfig.content;
+
+  const dictionariesPath = join(mainDir, 'dictionaries.mjs');
+  const relativeDictionariesPath = relative(baseDir, dictionariesPath);
+
+  return {
+    ...cracoConfig,
+    webpack: {
+      ...cracoConfig.webpack,
+      plugins: {
+        ...cracoConfig.webpack?.plugins,
+        add: [new webpack.EnvironmentPlugin(env), new IntLayerWebpackPlugin()],
+      },
+      alias: {
+        ...cracoConfig.webpack?.alias,
+        '@intlayer/dictionaries-entry': resolve('./', relativeDictionariesPath),
+      },
+    },
+  };
+};
+
+/**
+ * A CRACO plugin that adds the IntLayer configuration to the webpack configuration and sets the environment variables.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const cracoConfig: CracoConfig = {
+ *  plugins: [
+ *   {
+ *    plugin: intlayerCracoPlugin(),
+ *   },
+ *  ],
+ * };
+ *
+ * export default cracoConfig;
+ * ```
+ *
+ */
+export const plugin: CracoPlugin = {
+  overrideCracoConfig,
+  overrideWebpackConfig,
+};

package/src/getEnumeration.ts

@@ -1,6 +1,34 @@
 import { type QuantityContent, getEnumerationContent } from '@intlayer/core';
 import { contentRender } from './ContentEditor/contentRender';
 
+/**
+ * Allow to pick a content based on a quantity.
+ *
+ * Return either the content editor, or the content itself depending on the configuration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = getEnumeration({
+ *  '<=-2.3': 'You have less than -2.3',
+ *  '<1': 'You have less than one',
+ *  '2': 'You have two',
+ *  '>=3': 'You have three or more',
+ * }, 2);
+ * // 'You have two'
+ * ```
+ *
+ * The order of the keys will define the priority of the content.
+ *
+ * ```ts
+ * const content = getEnumeration({
+ *  '<4': 'You have less than four',
+ *  '2': 'You have two',
+ * }, 2);
+ * // 'You have less than four'
+ * ```
+ *
+ */
 export const getEnumeration = <Content>(
   enumerationContent: QuantityContent<Content>,
   quantity: number

package/src/getTranslation.ts

@@ -1,15 +1,33 @@
-import {
-  type Locales,
-  intlayerIntlConfiguration,
-} from '@intlayer/config/client';
+import { type Locales, getConfiguration } from '@intlayer/config/client';
 import { type LanguageContent, getTranslationContent } from '@intlayer/core';
 import { contentRender } from './ContentEditor/contentRender';
 
-export const getTranslation = <Content>(
+/**
+ *
+ * Allow to pick a content based on a locale.
+ * If not locale found, it will return the content related to the default locale.
+ *
+ * Return either the content editor, or the content itself depending on the configuration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = getTranslation<string>({
+ * en: 'Hello',
+ * fr: 'Bonjour',
+ * }, 'fr');
+ * // 'Bonjour'
+ * ```
+ *
+ * Using TypeScript:
+ * - this function will require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+export const getTranslation = <Content = string>(
   languageContent: LanguageContent<Content>,
   locale?: Locales
 ): Content => {
-  const { defaultLocale } = intlayerIntlConfiguration;
+  const { defaultLocale } = getConfiguration().internationalization;
 
   const result: Content = getTranslationContent<Content>(
     languageContent,

package/src/index.ts

@@ -1,14 +1,14 @@
 export { getTranslation } from './getTranslation';
 export {
-  LocaleClientContextProvider,
-  type LocaleClientContextProviderProps,
-  LocaleClientContext,
-  useLocaleContext,
+  IntlayerClientProvider,
+  type IntlayerClientProviderProps,
+  IntlayerClient,
   useIntlayer,
   useLocale,
   useTraduction,
   useLocaleCookie,
   localeCookie,
   setLocaleCookie,
+  getBrowserLocale,
+  useLocaleBase,
 } from './client/index';
-export {} from './client/useLocaleCookie';

package/src/processDictionary/index.ts

@@ -1,13 +1,11 @@
 /* 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,
 } from '@intlayer/core';
+import { type ReactElement, createElement, type ReactNode } from 'react';
 import { getEnumeration } from '../getEnumeration';
 import { getTranslation } from '../getTranslation';
 import type {
@@ -17,7 +15,7 @@ import type {
   TransformedContentValue,
 } from './contentDictionary';
 
-const defaultLocale = intlayerIntlConfiguration.defaultLocale;
+const { defaultLocale } = getConfiguration().internationalization;
 
 const processTranslation = (
   languageContent: LanguageContent<ContentValue>,
@@ -46,6 +44,9 @@ const processEnumeration = (
   };
 };
 
+const isReactNode = (node: Record<string, unknown>): boolean =>
+  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';
+
 export const processNode = (
   field: ContentValue | undefined,
   locale: Locales
@@ -72,13 +73,59 @@ export const processNode = (
   return field as TransformedContentValue;
 };
 
+// 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;
+  }
+
+  // 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);
+};
+
 /**
- * Function to replace the multi lingual content with content in the current locale
+ * Function that process a dictionary and return the result to be used in the application.
  */
 export const processDictionary = (
   content: Content,
   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 = {};
 

package/src/server/IntlayerServerProvider.tsx

@@ -0,0 +1,36 @@
+import { type Locales, getConfiguration } from '@intlayer/config/client';
+import type { FC, PropsWithChildren } from 'react';
+import { createServerContext, getServerContext } from './serverContext';
+
+/**
+ * Context that store the current locale on the server side
+ */
+export const IntlayerServerContext = createServerContext<Locales>(
+  getConfiguration().internationalization.defaultLocale
+);
+
+/**
+ * Hook that provides the current locale
+ */
+export const useIntlayer = () => getServerContext(IntlayerServerContext);
+
+/**
+ * Get the current locale
+ */
+export const locale = getServerContext(IntlayerServerContext);
+
+export type IntlayerServerProviderProps = PropsWithChildren & {
+  locale: Locales;
+};
+
+/**
+ * Provider that store the current locale on the server side
+ */
+export const IntlayerServerProvider: FC<IntlayerServerProviderProps> = ({
+  children,
+  locale,
+}) => (
+  <IntlayerServerContext.Provider value={locale}>
+    {children}
+  </IntlayerServerContext.Provider>
+);

package/src/server/getLocaleTranslation.ts

@@ -1,15 +1,18 @@
-import { intlayerIntlConfiguration } from '@intlayer/config/client';
+import { getConfiguration } from '@intlayer/config/client';
 import { type LanguageContent, getTranslationContent } from '@intlayer/core';
-import { LocaleServerContext } from './LocaleServerContextProvider';
+import { IntlayerServerContext } from './IntlayerServerProvider';
 import { getServerContext } from './serverContext';
 
+/**
+ * On the server side, get the translation content based on the locale
+ */
 export const getLocaleTranslation = <Content>(
   languageContent: LanguageContent<Content>
 ) => {
-  const locale = getServerContext(LocaleServerContext);
+  const locale = getServerContext(IntlayerServerContext);
   const content = getTranslationContent<Content>(
     languageContent,
-    locale ?? intlayerIntlConfiguration.defaultLocale
+    locale ?? getConfiguration().internationalization.defaultLocale
   );
 
   return {

package/src/server/index.ts

@@ -1,8 +1,8 @@
 export { getLocaleTranslation as getLocaleContent } from './getLocaleTranslation';
 export { useTraduction } from './useTraduction';
 export {
-  LocaleServerContext,
+  IntlayerServerContext as IntlayerServer,
   locale,
-  LocaleServerContextProvider,
-} from './LocaleServerContextProvider';
+  IntlayerServerProvider,
+} from './IntlayerServerProvider';
 export { useIntlayer } from './useIntlayer';

package/src/server/serverContext.ts

@@ -3,11 +3,11 @@
  * Attempts to closely mimic the `createContext` API.
  *
  * @example
- * const LocaleServerContext = createServerContext<string | null>(null);
+ * const IntlayerServer = createServerContext<string | null>(null);
  *
- * <LocaleServerContext.Provider value={locale}>
+ * <IntlayerServer.Provider value={locale}>
  *      {children}
- * </LocaleServerContext.Provider>
+ * </IntlayerServer.Provider>
  */
 
 import react from 'react';
@@ -44,7 +44,7 @@ export const createServerContext = <T>(defaultValue?: T): ServerContext<T> => {
  * Attempts to closely mimic the `useContext` API.
  *
  * @example
- * getServerContext(LocaleServerContext);
+ * getServerContext(IntlayerServer);
  */
 export const getServerContext = <T>({
   _storage,

package/src/server/useIntlayer.ts

@@ -4,14 +4,20 @@ import {
   useIntlayerBase,
   type UseIntlayer,
 } from '../useIntlayerBase';
-import { LocaleServerContext } from './LocaleServerContextProvider';
+import { IntlayerServerContext } from './IntlayerServerProvider';
 import { getServerContext } from './serverContext';
 
+/**
+ * On the server side, Hook that picking one dictionary by its id and return the content
+ *
+ * If the locale is not provided, it will use the locale from the server context
+ */
 export const useIntlayer: UseIntlayer = <T extends DictionaryKeys>(
   id: T,
   locale?: Locales
 ) => {
-  const localeTarget = locale ?? getServerContext<Locales>(LocaleServerContext);
+  const localeTarget =
+    locale ?? getServerContext<Locales>(IntlayerServerContext);
 
   return useIntlayerBase(id, localeTarget);
 };

package/src/server/useTraduction.ts

@@ -1,13 +1,34 @@
 import type { Locales } from '@intlayer/config/client';
 import type { LanguageContent } from '@intlayer/core';
 import { getTranslation } from '../getTranslation';
-import { LocaleServerContext } from './LocaleServerContextProvider';
+import { IntlayerServerContext } from './IntlayerServerProvider';
 import { getServerContext } from './serverContext';
 
-export const useTraduction = <Content>(
+/**
+ * On the server side, hook to get the translation content based on the locale
+ *
+ * If not locale found, it will return the content related to the default locale.
+ *
+ * Return either the content editor, or the content itself depending on the configuration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = useTraduction<string>({
+ * en: 'Hello',
+ * fr: 'Bonjour',
+ * }, 'fr');
+ * // 'Bonjour'
+ * ```
+ *
+ * Using TypeScript:
+ * - this function will require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+export const useTraduction = <Content = string>(
   languageContent: LanguageContent<Content>
 ) => {
-  const locale = getServerContext<Locales>(LocaleServerContext);
+  const locale = getServerContext<Locales>(IntlayerServerContext);
 
   return getTranslation(languageContent, locale);
 };

package/src/useIntlayerBase.ts

@@ -1,9 +1,9 @@
+import type { Locales } from '@intlayer/config/client';
 /**
  * @intlayer/dictionaries-entry is a package that only returns the dictionary entry path.
  * Using an external package allow to alias it in the bundle configuration (such as webpack).
  * The alias allow hot reload the app (such as nextjs) on any dictionary change.
  */
-import type { Locales } from '@intlayer/config/client';
 import dictionaries from '@intlayer/dictionaries-entry';
 import type { IntlayerDictionaryTypesConnector } from 'intlayer';
 import type { Content } from './processDictionary/contentDictionary';
@@ -19,6 +19,9 @@ export type UseIntlayer = <T extends DictionaryKeys>(
   locale?: Locales
 ) => IntlayerDictionaryTypesConnector[T];
 
+/**
+ * Hook that picking one dictionary by its id and return the content.
+ */
 export const useIntlayerBase: UseIntlayer = <T extends DictionaryKeys>(
   id: T,
   locale?: Locales

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: (server) => {
+    // Custom server configuration, if needed
+  },
+});

package/dist/cjs/LocaleContextProvider.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/LocaleContextProvider.tsx"],"sourcesContent":["import { intlayerIntlConfiguration } from '@intlayer/config/client';\nimport React, { type FC } from 'react';\nimport {\n  LocaleClientContextProvider,\n  type LocaleClientContextProviderProps,\n} from './client/LocaleClientContextProvider';\nimport {\n  LocaleServerContextProvider,\n  type LocaleServerContextProviderProps,\n} from './server/LocaleServerContextProvider';\n\nconst defaultLocale = intlayerIntlConfiguration.defaultLocale;\n\ntype LocaleContextProviderProps = LocaleClientContextProviderProps &\n  LocaleServerContextProviderProps;\n\nexport const LocaleContextProvider: FC<LocaleContextProviderProps> = ({\n  children,\n  locale = defaultLocale,\n}) => (\n  <LocaleServerContextProvider locale={locale}>\n    <LocaleClientContextProvider locale={locale}>\n      {children}\n    </LocaleClientContextProvider>\n  </LocaleServerContextProvider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBI;AArBJ,oBAA0C;AAE1C,yCAGO;AACP,yCAGO;AAEP,MAAM,gBAAgB,wCAA0B;AAKzC,MAAM,wBAAwD,CAAC;AAAA,EACpE;AAAA,EACA,SAAS;AACX,MACE,4CAAC,kEAA4B,QAC3B,sDAAC,kEAA4B,QAC1B,UACH,GACF;","names":[]}

package/dist/cjs/LocaleContextProvider.d.ts

@@ -1,9 +0,0 @@
-import { FC } from 'react';
-import { LocaleClientContextProviderProps } from './client/LocaleClientContextProvider.js';
-import { LocaleServerContextProviderProps } from './server/LocaleServerContextProvider.js';
-import '@intlayer/config/client';
-
-type LocaleContextProviderProps = LocaleClientContextProviderProps & LocaleServerContextProviderProps;
-declare const LocaleContextProvider: FC<LocaleContextProviderProps>;
-
-export { LocaleContextProvider };

package/dist/cjs/client/LocaleClientContextProvider.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/client/LocaleClientContextProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  intlayerIntlConfiguration,\n  type Locales,\n} from '@intlayer/config/client';\nimport {\n  type PropsWithChildren,\n  createContext,\n  useContext,\n  type FC,\n} from 'react';\nimport { localeCookie } from './useLocaleCookie';\n\ntype LocaleContextValue = {\n  locale: Locales;\n};\n\nexport const LocaleClientContext = createContext<LocaleContextValue>({\n  locale: localeCookie ?? intlayerIntlConfiguration.defaultLocale,\n});\n\nexport const useLocaleContext = () => useContext(LocaleClientContext);\n\nexport type LocaleClientContextProviderProps = PropsWithChildren & {\n  locale: Locales;\n};\n\nexport const LocaleClientContextProvider: FC<\n  LocaleClientContextProviderProps\n> = ({ locale, children }) => (\n  <LocaleClientContext.Provider value={{ locale }}>\n    {children}\n  </LocaleClientContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BE;AA7BF,oBAGO;AACP,mBAKO;AACP,6BAA6B;AAMtB,MAAM,0BAAsB,4BAAkC;AAAA,EACnE,QAAQ,uCAAgB,wCAA0B;AACpD,CAAC;AAEM,MAAM,mBAAmB,UAAM,yBAAW,mBAAmB;AAM7D,MAAM,8BAET,CAAC,EAAE,QAAQ,SAAS,MACtB,4CAAC,oBAAoB,UAApB,EAA6B,OAAO,EAAE,OAAO,GAC3C,UACH;","names":[]}

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

@@ -1,15 +0,0 @@
-import * as react from 'react';
-import { PropsWithChildren, FC } from 'react';
-import { Locales } from '@intlayer/config/client';
-
-type LocaleContextValue = {
-    locale: Locales;
-};
-declare const LocaleClientContext: react.Context<LocaleContextValue>;
-declare const useLocaleContext: () => LocaleContextValue;
-type LocaleClientContextProviderProps = PropsWithChildren & {
-    locale: Locales;
-};
-declare const LocaleClientContextProvider: FC<LocaleClientContextProviderProps>;
-
-export { LocaleClientContext, LocaleClientContextProvider, type LocaleClientContextProviderProps, useLocaleContext };

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

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

package/dist/esm/LocaleContextProvider.d.mts

@@ -1,9 +0,0 @@
-import { FC } from 'react';
-import { LocaleClientContextProviderProps } from './client/LocaleClientContextProvider.mjs';
-import { LocaleServerContextProviderProps } from './server/LocaleServerContextProvider.mjs';
-import '@intlayer/config/client';
-
-type LocaleContextProviderProps = LocaleClientContextProviderProps & LocaleServerContextProviderProps;
-declare const LocaleContextProvider: FC<LocaleContextProviderProps>;
-
-export { LocaleContextProvider };

package/dist/esm/LocaleContextProvider.mjs

@@ -1,17 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { intlayerIntlConfiguration } from "@intlayer/config/client";
-import {
-  LocaleClientContextProvider
-} from './client/LocaleClientContextProvider.mjs';
-import {
-  LocaleServerContextProvider
-} from './server/LocaleServerContextProvider.mjs';
-const defaultLocale = intlayerIntlConfiguration.defaultLocale;
-const LocaleContextProvider = ({
-  children,
-  locale = defaultLocale
-}) => /* @__PURE__ */ jsx(LocaleServerContextProvider, { locale, children: /* @__PURE__ */ jsx(LocaleClientContextProvider, { locale, children }) });
-export {
-  LocaleContextProvider
-};
-//# sourceMappingURL=LocaleContextProvider.mjs.map

package/dist/esm/LocaleContextProvider.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/LocaleContextProvider.tsx"],"sourcesContent":["import { intlayerIntlConfiguration } from '@intlayer/config/client';\nimport React, { type FC } from 'react';\nimport {\n  LocaleClientContextProvider,\n  type LocaleClientContextProviderProps,\n} from './client/LocaleClientContextProvider';\nimport {\n  LocaleServerContextProvider,\n  type LocaleServerContextProviderProps,\n} from './server/LocaleServerContextProvider';\n\nconst defaultLocale = intlayerIntlConfiguration.defaultLocale;\n\ntype LocaleContextProviderProps = LocaleClientContextProviderProps &\n  LocaleServerContextProviderProps;\n\nexport const LocaleContextProvider: FC<LocaleContextProviderProps> = ({\n  children,\n  locale = defaultLocale,\n}) => (\n  <LocaleServerContextProvider locale={locale}>\n    <LocaleClientContextProvider locale={locale}>\n      {children}\n    </LocaleClientContextProvider>\n  </LocaleServerContextProvider>\n);\n"],"mappings":"AAqBI;AArBJ,SAAS,iCAAiC;AAE1C;AAAA,EACE;AAAA,OAEK;AACP;AAAA,EACE;AAAA,OAEK;AAEP,MAAM,gBAAgB,0BAA0B;AAKzC,MAAM,wBAAwD,CAAC;AAAA,EACpE;AAAA,EACA,SAAS;AACX,MACE,oBAAC,+BAA4B,QAC3B,8BAAC,+BAA4B,QAC1B,UACH,GACF;","names":[]}

package/dist/esm/client/LocaleClientContextProvider.d.mts

@@ -1,15 +0,0 @@
-import * as react from 'react';
-import { PropsWithChildren, FC } from 'react';
-import { Locales } from '@intlayer/config/client';
-
-type LocaleContextValue = {
-    locale: Locales;
-};
-declare const LocaleClientContext: react.Context<LocaleContextValue>;
-declare const useLocaleContext: () => LocaleContextValue;
-type LocaleClientContextProviderProps = PropsWithChildren & {
-    locale: Locales;
-};
-declare const LocaleClientContextProvider: FC<LocaleClientContextProviderProps>;
-
-export { LocaleClientContext, LocaleClientContextProvider, type LocaleClientContextProviderProps, useLocaleContext };