@intlayer/config 1.2.0 → 1.2.1

package/src/configFile/buildConfigurationFields.ts

@@ -17,6 +17,8 @@ import {
   TYPES_DIR_NAME,
   MAIN_DIR_NAME,
   MODULE_AUGMENTATION_DIR_NAME,
+  I18N_DICTIONARIES_DIR_NAME,
+  DICTIONARY_OUTPUT,
 } from '../defaultValues/server';
 import type {
   BaseDerivedConfig,
@@ -42,6 +44,7 @@ const buildInternationalizationFields = (
    * Locales available in the application
    *
    * Default: ['en']
+   *
    */
   locales: customConfiguration?.locales ?? LOCALES,
 
@@ -122,7 +125,7 @@ const buildContentFields = (
     /**
      * File extensions of content to look for to build the dictionaries
      *
-     * - Default: ['.content.ts', '.content.js', '.content.json']
+     * - Default: ['.content.ts', '.content.js', '.content.cjs', '.content.mjs', '.content.json', '.content.tsx', '.content.jsx']
      *
      * - Example: ['.data.ts', '.data.js', '.data.json']
      *
@@ -207,6 +210,23 @@ const buildContentFields = (
     dictionariesDirName:
       customConfiguration?.dictionariesDirName ?? DICTIONARIES_DIR_NAME,
 
+    /**
+     * Related to the intlayer result directory
+     *
+     * Directory name where the dictionaries will be stored
+     *
+     * Default: 'dictionary'
+     *
+     * Example: 'translations'
+     *
+     * Note:
+     * - If this directory is not at the result directory level, update the dictionariesDir field instead
+     *
+     */
+    i18nDictionariesDirName:
+      customConfiguration?.i18nDictionariesDirName ??
+      I18N_DICTIONARIES_DIR_NAME,
+
     /**
      *  Related to the intlayer result directory
      *
@@ -304,6 +324,18 @@ const buildContentFields = (
       notDerivedContentConfig.baseDir,
       notDerivedContentConfig.moduleAugmentationDirName
     ),
+
+    /**
+     * Output format of the dictionary
+     *
+     * Default: ['intlayer']
+     *
+     * Note:
+     * - 'i18next' is not yet ensure a 1:1 mapping with the i18next library.
+     * - Removing 'intlayer' will break the compatibility with react-intlayer or next-intlayer
+     */
+    dictionaryOutput:
+      customConfiguration?.dictionaryOutput ?? DICTIONARY_OUTPUT,
   };
 
   const resultDirDerivedConfiguration: ResultDirDerivedConfig = {
@@ -327,6 +359,23 @@ const buildContentFields = (
       notDerivedContentConfig.dictionariesDirName
     ),
 
+    /**
+     * Directory where the 18n dictionaries will be stored
+     *
+     * Relative to the result directory
+     *
+     * Default: {{resultDir}} / {{i18nDictionariesDirName}}
+     *
+     * Example: '/path/to/project/.intlayer/dictionary/i18n'
+     *
+     * Note:
+     * - If the types are not at the result directory level, update the i18nDictionariesDirName field instead
+     */
+    i18nDictionariesDir: join(
+      baseDirDerivedConfiguration.resultDir,
+      notDerivedContentConfig.i18nDictionariesDirName
+    ),
+
     /**
      * Directory where the dictionaries types will be stored
      *
@@ -367,7 +416,7 @@ const buildContentFields = (
     /**
      * Pattern of files to watch
      *
-     * Default: ['/**\/*.content.ts', '/**\/*.content.js', '/**\/*.content.json']
+     * Default: ['/**\/*.content.ts', '/**\/*.content.js', '/**\/*.content.json', '/**\/*.content.cjs', '/**\/*.content.mjs', '/**\/*.content.tsx', '/**\/*.content.jsx']
      */
     watchedFilesPattern: notDerivedContentConfig.fileExtensions.map(
       (ext) => `/**/*${ext}`
@@ -376,7 +425,7 @@ const buildContentFields = (
     /**
      * Pattern of files to watch including the relative path
      *
-     * Default: ['{{contentDir}}/**\/*.content.ts', '{{contentDir}}/**\/*.content.js', '{{contentDir}}/**\/*.content.json']
+     * Default: ['{{contentDir}}/**\/*.content.ts', '{{contentDir}}/**\/*.content.js', '{{contentDir}}/**\/*.content.json', '{{contentDir}}/**\/*.content.cjs', '{{contentDir}}/**\/*.content.mjs', '{{contentDir}}/**\/*.content.tsx', '{{contentDir}}/**\/*.content.jsx']
      */
     watchedFilesPatternWithPath: notDerivedContentConfig.fileExtensions.map(
       (ext) => `${baseDirDerivedConfiguration.contentDir}/**/*${ext}`

package/src/defaultValues/server.ts

@@ -1,4 +1,14 @@
-export const FILE_EXTENSIONS = ['.content.ts', '.content.js', '.content.json'];
+import type { DictionaryOutput } from '../types/config';
+
+export const FILE_EXTENSIONS = [
+  '.content.ts',
+  '.content.js',
+  '.content.cjs',
+  '.content.mjs',
+  '.content.json',
+  '.content.tsx',
+  '.content.jsx',
+];
 export const EXCLUDED_PATHS = ['node_modules'];
 
 export const CONTENT_DIR_NAME = 'src';
@@ -7,8 +17,12 @@ export const RESULT_DIR_NAME = '.intlayer';
 
 export const MODULE_AUGMENTATION_DIR_NAME = 'types';
 
+export const DICTIONARY_OUTPUT: DictionaryOutput[] = ['intlayer'];
+
 export const DICTIONARIES_DIR_NAME = 'dictionary';
 
+export const I18N_DICTIONARIES_DIR_NAME = 'i18n_dictionary';
+
 export const TYPES_DIR_NAME = 'types';
 
 export const MAIN_DIR_NAME = 'main';

package/src/envVariables/detectPlatform.ts

@@ -1,20 +1,24 @@
 export type Platform = 'next' | 'vite' | 'react_app' | 'unknown';
-export type ViteEnvVar = { env: Record<string, string> };
 
 export const getPlatform = (): Platform => {
-  if (typeof process.env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE === 'string') {
+  if (
+    // eslint-disable-next-line
+    typeof import.meta !== 'undefined' &&
+    typeof import.meta.env !== 'undefined' &&
+    typeof import.meta.env.VITE_INTLAYER_DEFAULT_LOCALE !== 'undefined'
+  ) {
+    // Likely Vite
+    return 'vite';
+  } else if (
+    typeof process.env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE !== 'undefined'
+  ) {
     // Likely Next.js
     return 'next';
   } else if (
-    typeof process.env.REACT_APP_INTLAYER_DEFAULT_LOCALE === 'string'
+    typeof process.env.REACT_APP_INTLAYER_DEFAULT_LOCALE !== 'undefined'
   ) {
     // Likely Create React App
     return 'react_app';
-  } else if (
-    (import.meta as unknown as ViteEnvVar)?.env?.VITE_INTLAYER_DEFAULT_LOCALE
-  ) {
-    // Likely Vite
-    return 'vite';
   }
 
   return 'unknown';

package/src/envVariables/extractEnvVariable/index.ts

@@ -0,0 +1,20 @@
+import { type Platform, getPlatform } from '../detectPlatform';
+import { extractNextEnvVariable } from './next';
+import { extractReactAppEnvVariable } from './react_app';
+import type { IntlayerConfigEnvVariable } from './types';
+import { extractEmptyEnvVariable } from './undefined_platform';
+import { extractViteEnvVariable } from './vite';
+
+export const extractEnvVariable = (): IntlayerConfigEnvVariable => {
+  const platform: Platform = getPlatform();
+
+  if (platform === 'vite') {
+    return extractViteEnvVariable();
+  } else if (platform === 'next') {
+    return extractNextEnvVariable();
+  } else if (platform === 'react_app') {
+    return extractReactAppEnvVariable();
+  }
+
+  return extractEmptyEnvVariable();
+};

package/src/envVariables/extractEnvVariable/next.ts

@@ -0,0 +1,57 @@
+import type {
+  InternationalizationConfig,
+  MiddlewareConfig,
+  ContentConfig,
+} from '../../types/config';
+import type { IntlayerConfigEnvVariable, ReplaceValue } from './types';
+
+export const extractNextEnvVariable = (): IntlayerConfigEnvVariable => {
+  const internationalization: ReplaceValue<InternationalizationConfig> = {
+    locales: process.env.NEXT_PUBLIC_INTLAYER_LOCALES,
+    defaultLocale: process.env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const middleware: ReplaceValue<MiddlewareConfig> = {
+    headerName: process.env.NEXT_PUBLIC_INTLAYER_HEADER_NAME,
+    cookieName: process.env.NEXT_PUBLIC_INTLAYER_COOKIE_NAME,
+    prefixDefault: process.env.NEXT_PUBLIC_INTLAYER_PREFIX_DEFAULT,
+    basePath: process.env.NEXT_PUBLIC_INTLAYER_BASE_PATH,
+    serverSetCookie: process.env.NEXT_PUBLIC_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: process.env.NEXT_PUBLIC_INTLAYER_NO_PREFIX,
+  };
+
+  const content: ReplaceValue<ContentConfig> = {
+    fileExtensions: process.env.NEXT_PUBLIC_INTLAYER_FILE_EXTENSIONS,
+    baseDir: process.env.NEXT_PUBLIC_INTLAYER_BASE_DIR,
+    contentDirName: process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR,
+    excludedPath: process.env.NEXT_PUBLIC_INTLAYER_EXCLUDED_PATH,
+    resultDirName: process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName:
+      process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR_NAME,
+    i18nDictionariesDir: process.env.NEXT_PUBLIC_INTLAYER_I18N_DICTIONARIES_DIR,
+    typeDirName: process.env.NEXT_PUBLIC_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR_NAME,
+    resultDir: process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir:
+      process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR,
+    i18nDictionariesDirName:
+      process.env.NEXT_PUBLIC_INTLAYER_I18N_DICTIONARIES_DIR_NAME,
+    typesDir: process.env.NEXT_PUBLIC_INTLAYER_TYPE_DIR,
+    mainDir: process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath:
+      process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath:
+      process.env.NEXT_PUBLIC_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+    dictionaryOutput: process.env.NEXT_PUBLIC_INTLAYER_DICTIONARY_OUTPUT,
+  };
+
+  return {
+    internationalization,
+    middleware,
+    content,
+  };
+};

package/src/envVariables/extractEnvVariable/react_app.ts

@@ -0,0 +1,57 @@
+import type {
+  InternationalizationConfig,
+  MiddlewareConfig,
+  ContentConfig,
+} from '../../types/config';
+import type { IntlayerConfigEnvVariable, ReplaceValue } from './types';
+
+export const extractReactAppEnvVariable = (): IntlayerConfigEnvVariable => {
+  const internationalization: ReplaceValue<InternationalizationConfig> = {
+    locales: process.env.REACT_APP_INTLAYER_LOCALES,
+    defaultLocale: process.env.REACT_APP_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const middleware: ReplaceValue<MiddlewareConfig> = {
+    headerName: process.env.REACT_APP_INTLAYER_HEADER_NAME,
+    cookieName: process.env.REACT_APP_INTLAYER_COOKIE_NAME,
+    prefixDefault: process.env.REACT_APP_INTLAYER_PREFIX_DEFAULT,
+    basePath: process.env.REACT_APP_INTLAYER_BASE_PATH,
+    serverSetCookie: process.env.REACT_APP_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: process.env.REACT_APP_INTLAYER_NO_PREFIX,
+  };
+
+  const content: ReplaceValue<ContentConfig> = {
+    fileExtensions: process.env.REACT_APP_INTLAYER_FILE_EXTENSIONS,
+    baseDir: process.env.REACT_APP_INTLAYER_BASE_DIR,
+    contentDirName: process.env.REACT_APP_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: process.env.REACT_APP_INTLAYER_CONTENT_DIR,
+    excludedPath: process.env.REACT_APP_INTLAYER_EXCLUDED_PATH,
+    resultDirName: process.env.REACT_APP_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName:
+      process.env.REACT_APP_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: process.env.REACT_APP_INTLAYER_DICTIONARIES_DIR_NAME,
+    i18nDictionariesDirName:
+      process.env.REACT_APP_INTLAYER_I18N_DICTIONARIES_DIR_NAME,
+    typeDirName: process.env.REACT_APP_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: process.env.REACT_APP_INTLAYER_MAIN_DIR_NAME,
+    resultDir: process.env.REACT_APP_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir:
+      process.env.REACT_APP_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: process.env.REACT_APP_INTLAYER_DICTIONARIES_DIR,
+    i18nDictionariesDir: process.env.REACT_APP_INTLAYER_I18N_DICTIONARIES_DIR,
+    typesDir: process.env.REACT_APP_INTLAYER_TYPE_DIR,
+    mainDir: process.env.REACT_APP_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: process.env.REACT_APP_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath:
+      process.env.REACT_APP_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath:
+      process.env.REACT_APP_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+    dictionaryOutput: process.env.REACT_APP_INTLAYER_DICTIONARY_OUTPUT,
+  };
+
+  return {
+    internationalization,
+    middleware,
+    content,
+  };
+};

package/src/envVariables/extractEnvVariable/types.ts

@@ -0,0 +1,10 @@
+import type { IntlayerConfig } from '../../client';
+
+// Utility type that replaces all values of a given type with another type
+export type ReplaceValue<T> = {
+  [K in keyof T]: string | undefined;
+};
+
+export type IntlayerConfigEnvVariable = {
+  [K in keyof IntlayerConfig]: ReplaceValue<IntlayerConfig[K]>;
+};

package/src/envVariables/extractEnvVariable/undefined_platform.ts

@@ -0,0 +1,52 @@
+import type {
+  InternationalizationConfig,
+  MiddlewareConfig,
+  ContentConfig,
+} from '../../types/config';
+import type { ReplaceValue, IntlayerConfigEnvVariable } from './types';
+
+export const extractEmptyEnvVariable = (): IntlayerConfigEnvVariable => {
+  const internationalization: ReplaceValue<InternationalizationConfig> = {
+    locales: undefined,
+    defaultLocale: undefined,
+  };
+
+  const middleware: ReplaceValue<MiddlewareConfig> = {
+    headerName: undefined,
+    cookieName: undefined,
+    prefixDefault: undefined,
+    basePath: undefined,
+    serverSetCookie: undefined,
+    noPrefix: undefined,
+  };
+
+  const content: ReplaceValue<ContentConfig> = {
+    fileExtensions: undefined,
+    baseDir: undefined,
+    contentDirName: undefined,
+    contentDir: undefined,
+    excludedPath: undefined,
+    resultDirName: undefined,
+    moduleAugmentationDirName: undefined,
+    dictionariesDirName: undefined,
+    i18nDictionariesDirName: undefined,
+    typeDirName: undefined,
+    mainDirName: undefined,
+    resultDir: undefined,
+    moduleAugmentationDir: undefined,
+    dictionariesDir: undefined,
+    i18nDictionariesDir: undefined,
+    typesDir: undefined,
+    mainDir: undefined,
+    watchedFilesPattern: undefined,
+    watchedFilesPatternWithPath: undefined,
+    outputFilesPatternWithPath: undefined,
+    dictionaryOutput: undefined,
+  };
+
+  return {
+    internationalization,
+    middleware,
+    content,
+  };
+};

package/src/envVariables/extractEnvVariable/vite.ts

@@ -0,0 +1,65 @@
+import type {
+  InternationalizationConfig,
+  MiddlewareConfig,
+  ContentConfig,
+} from '../../types/config';
+import type { IntlayerConfigEnvVariable, ReplaceValue } from './types';
+import { extractEmptyEnvVariable } from './undefined_platform';
+
+export const extractViteEnvVariable = (): IntlayerConfigEnvVariable => {
+  if (!import.meta.env) {
+    console.error(
+      'Vite env variables cannot be loaded on a commonjs environment.'
+    );
+    return extractEmptyEnvVariable();
+  }
+
+  const internationalization: ReplaceValue<InternationalizationConfig> = {
+    locales: import.meta.env.VITE_INTLAYER_LOCALES,
+    defaultLocale: import.meta.env.VITE_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const middleware: ReplaceValue<MiddlewareConfig> = {
+    headerName: import.meta.env.VITE_INTLAYER_HEADER_NAME,
+    cookieName: import.meta.env.VITE_INTLAYER_COOKIE_NAME,
+    prefixDefault: import.meta.env.VITE_INTLAYER_PREFIX_DEFAULT,
+    basePath: import.meta.env.VITE_INTLAYER_BASE_PATH,
+    serverSetCookie: import.meta.env.VITE_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: import.meta.env.VITE_INTLAYER_NO_PREFIX,
+  };
+
+  const content: ReplaceValue<ContentConfig> = {
+    fileExtensions: import.meta.env.VITE_INTLAYER_FILE_EXTENSIONS,
+    baseDir: import.meta.env.VITE_INTLAYER_BASE_DIR,
+    contentDirName: import.meta.env.VITE_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: import.meta.env.VITE_INTLAYER_CONTENT_DIR,
+    excludedPath: import.meta.env.VITE_INTLAYER_EXCLUDED_PATH,
+    resultDirName: import.meta.env.VITE_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName: import.meta.env
+      .VITE_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: import.meta.env.VITE_INTLAYER_DICTIONARIES_DIR_NAME,
+    i18nDictionariesDirName: import.meta.env
+      .VITE_INTLAYER_I18N_DICTIONARIES_DIR_NAME,
+    typeDirName: import.meta.env.VITE_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: import.meta.env.VITE_INTLAYER_MAIN_DIR_NAME,
+    resultDir: import.meta.env.VITE_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir: import.meta.env
+      .VITE_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: import.meta.env.VITE_INTLAYER_DICTIONARIES_DIR,
+    i18nDictionariesDir: import.meta.env.VITE_INTLAYER_I18N_DICTIONARIES_DIR,
+    typesDir: import.meta.env.VITE_INTLAYER_TYPE_DIR,
+    mainDir: import.meta.env.VITE_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: import.meta.env.VITE_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath: import.meta.env
+      .VITE_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath: import.meta.env
+      .VITE_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+    dictionaryOutput: import.meta.env.VITE_INTLAYER_DICTIONARY_OUTPUT,
+  };
+
+  return {
+    internationalization,
+    middleware,
+    content,
+  };
+};

package/src/envVariables/extractEnvVariable/vite_env.d.ts

@@ -0,0 +1,9 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+/**
+ * Module augmentation to add the `env` property to `import.meta`
+ *
+ * Simulate a vite environment
+ */
+interface ImportMeta {
+  env: Record<string, string | undefined>;
+}

package/src/envVariables/getConfiguration.ts

@@ -1,126 +1,99 @@
 import type {
   ContentConfig,
+  DictionaryOutput,
   InternationalizationConfig,
   IntlayerConfig,
   MiddlewareConfig,
   ServerSetCookieRule,
 } from '../types/config';
 import type { Locales } from '../types/locales';
-import { extractEnvVariable } from './extractEnvVariable';
+import { extractEnvVariable } from './extractEnvVariable/index';
 import { getEnvValue } from './utils';
 
-const env = extractEnvVariable();
-
-export const intlayerIntlConfiguration: InternationalizationConfig = {
-  locales: getEnvValue<Locales>(
-    env.intlayerIntlConfiguration.locales,
-    'array'
-  )!,
-  defaultLocale: getEnvValue<Locales>(
-    env.intlayerIntlConfiguration.defaultLocale,
-    'string'
-  )!,
-};
-
-export const intlayerMiddlewareConfiguration: MiddlewareConfig = {
-  headerName: getEnvValue(
-    env.intlayerMiddlewareConfiguration.headerName,
-    'string'
-  )!,
-  cookieName: getEnvValue(
-    env.intlayerMiddlewareConfiguration.cookieName,
-    'string'
-  )!,
-  prefixDefault: getEnvValue(
-    env.intlayerMiddlewareConfiguration.prefixDefault,
-    'boolean'
-  )!,
-  basePath: getEnvValue(
-    env.intlayerMiddlewareConfiguration.basePath,
-    'string'
-  )!,
-  serverSetCookie: getEnvValue<ServerSetCookieRule>(
-    env.intlayerMiddlewareConfiguration.serverSetCookie,
-    'string'
-  )!,
-  noPrefix: getEnvValue(
-    env.intlayerMiddlewareConfiguration.noPrefix,
-    'boolean'
-  )!,
-};
-
-export const intlayerContentConfiguration: ContentConfig = {
-  fileExtensions: getEnvValue<string>(
-    env.intlayerContentConfiguration.fileExtensions,
-    'array'
-  )!,
-  baseDir: getEnvValue(env.intlayerContentConfiguration.baseDir, 'string')!,
-  contentDirName: getEnvValue(
-    env.intlayerContentConfiguration.contentDirName,
-    'string'
-  )!,
-  contentDir: getEnvValue(
-    env.intlayerContentConfiguration.contentDir,
-    'string'
-  )!,
-  excludedPath: getEnvValue<string>(
-    env.intlayerContentConfiguration.excludedPath,
-    'array'
-  )!,
-  resultDirName: getEnvValue(
-    env.intlayerContentConfiguration.resultDirName,
-    'string'
-  )!,
-  resultDir: getEnvValue(env.intlayerContentConfiguration.resultDir, 'string')!,
-  moduleAugmentationDirName: getEnvValue(
-    env.intlayerContentConfiguration.moduleAugmentationDirName,
-    'string'
-  )!,
-  moduleAugmentationDir: getEnvValue(
-    env.intlayerContentConfiguration.moduleAugmentationDir,
-    'string'
-  )!,
-  dictionariesDirName: getEnvValue(
-    env.intlayerContentConfiguration.dictionariesDirName,
-    'string'
-  )!,
-  dictionariesDir: getEnvValue(
-    env.intlayerContentConfiguration.dictionariesDir,
-    'string'
-  )!,
-  typeDirName: getEnvValue(
-    env.intlayerContentConfiguration.typeDirName,
-    'string'
-  )!,
-  typesDir: getEnvValue(env.intlayerContentConfiguration.typesDir, 'string')!,
-  mainDirName: getEnvValue(
-    env.intlayerContentConfiguration.mainDirName,
-    'string'
-  )!,
-  mainDir: getEnvValue(env.intlayerContentConfiguration.mainDir, 'string')!,
-  watchedFilesPattern: getEnvValue<string>(
-    env.intlayerContentConfiguration.watchedFilesPattern,
-    'array'
-  )!,
-  watchedFilesPatternWithPath: getEnvValue<string>(
-    env.intlayerContentConfiguration.watchedFilesPatternWithPath,
-    'array'
-  )!,
-  outputFilesPatternWithPath: getEnvValue(
-    env.intlayerContentConfiguration.outputFilesPatternWithPath,
-    'string'
-  )!,
-};
-
-export const intlayerConfiguration: IntlayerConfig = {
-  internationalization: intlayerIntlConfiguration,
-  middleware: intlayerMiddlewareConfiguration,
-  content: intlayerContentConfiguration,
-};
-
 /**
  * Get all configuration values using environment variables
  * Can be used in the client side as the server side
  * To use it, be sure to have the environment variables set
  */
-export const getConfiguration = (): IntlayerConfig => intlayerConfiguration;
+export const getConfiguration = (): IntlayerConfig => {
+  const env = extractEnvVariable();
+
+  const intlayerIntlConfiguration: InternationalizationConfig = {
+    locales: getEnvValue<Locales>(env.internationalization.locales, 'array')!,
+    defaultLocale: getEnvValue<Locales>(
+      env?.internationalization.defaultLocale,
+      'string'
+    )!,
+  };
+
+  const intlayerMiddlewareConfiguration: MiddlewareConfig = {
+    headerName: getEnvValue(env.middleware.headerName, 'string')!,
+    cookieName: getEnvValue(env.middleware.cookieName, 'string')!,
+    prefixDefault: getEnvValue(env.middleware.prefixDefault, 'boolean')!,
+    basePath: getEnvValue(env.middleware.basePath, 'string')!,
+    serverSetCookie: getEnvValue<ServerSetCookieRule>(
+      env.middleware.serverSetCookie,
+      'string'
+    )!,
+    noPrefix: getEnvValue(env.middleware.noPrefix, 'boolean')!,
+  };
+
+  const intlayerContentConfiguration: ContentConfig = {
+    fileExtensions: getEnvValue<string>(env.content.fileExtensions, 'array')!,
+    baseDir: getEnvValue(env.content.baseDir, 'string')!,
+    contentDirName: getEnvValue(env.content.contentDirName, 'string')!,
+    contentDir: getEnvValue(env.content.contentDir, 'string')!,
+    excludedPath: getEnvValue<string>(env.content.excludedPath, 'array')!,
+    resultDirName: getEnvValue(env.content.resultDirName, 'string')!,
+    resultDir: getEnvValue(env.content.resultDir, 'string')!,
+    moduleAugmentationDirName: getEnvValue(
+      env.content.moduleAugmentationDirName,
+      'string'
+    )!,
+    moduleAugmentationDir: getEnvValue(
+      env.content.moduleAugmentationDir,
+      'string'
+    )!,
+    dictionaryOutput: getEnvValue<DictionaryOutput>(
+      env.content.dictionaryOutput,
+      'array'
+    )!,
+    dictionariesDirName: getEnvValue(
+      env.content.dictionariesDirName,
+      'string'
+    )!,
+    dictionariesDir: getEnvValue(env.content.dictionariesDir, 'string')!,
+    i18nDictionariesDirName: getEnvValue(
+      env.content.i18nDictionariesDirName,
+      'string'
+    )!,
+    i18nDictionariesDir: getEnvValue(
+      env.content.i18nDictionariesDir,
+      'string'
+    )!,
+    typeDirName: getEnvValue(env.content.typeDirName, 'string')!,
+    typesDir: getEnvValue(env.content.typesDir, 'string')!,
+    mainDirName: getEnvValue(env.content.mainDirName, 'string')!,
+    mainDir: getEnvValue(env.content.mainDir, 'string')!,
+    watchedFilesPattern: getEnvValue<string>(
+      env.content.watchedFilesPattern,
+      'array'
+    )!,
+    watchedFilesPatternWithPath: getEnvValue<string>(
+      env.content.watchedFilesPatternWithPath,
+      'array'
+    )!,
+    outputFilesPatternWithPath: getEnvValue(
+      env.content.outputFilesPatternWithPath,
+      'string'
+    )!,
+  };
+
+  const intlayerConfiguration: IntlayerConfig = {
+    internationalization: intlayerIntlConfiguration,
+    middleware: intlayerMiddlewareConfiguration,
+    content: intlayerContentConfiguration,
+  };
+
+  return intlayerConfiguration;
+};

package/src/envVariables/index.ts

@@ -1,8 +1,2 @@
-export {
-  intlayerIntlConfiguration,
-  intlayerMiddlewareConfiguration,
-  intlayerContentConfiguration,
-  intlayerConfiguration,
-  getConfiguration,
-} from './getConfiguration';
+export { getConfiguration } from './getConfiguration';
 export { formatEnvVariable } from './formatEnvVariable';

package/src/index.ts

@@ -16,9 +16,5 @@ export type { LocalesValues } from './types/locales';
 export { Locales } from './types/locales';
 export {
   formatEnvVariable,
-  intlayerIntlConfiguration,
-  intlayerMiddlewareConfiguration,
-  intlayerContentConfiguration,
-  intlayerConfiguration,
   getConfiguration as getClientConfiguration,
 } from './envVariables/index';