@intlayer/config 1.0.2 → 1.2.1

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/formatEnvVariable.ts

@@ -1,18 +1,24 @@
 import { getConfiguration } from '../configFile/getConfiguration';
+import { getPrefix, type Platform } from './detectPlatform';
 
+/**
+ * Format a key to corresponding environment variable name
+ *
+ * Example:
+ *  toEnvVariable('mainDir') => 'INTLAYER_MAIN_DIR'
+ */
+const formatEnvName = (key: string, prefix: string): string =>
+  prefix + key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+
+/**
+ * Format all configuration values as environment variables
+ */
 export const formatEnvVariable = (
-  prefix = 'NEXT_PUBLIC_INTLAYER_'
+  platform: Platform
 ): Record<string, string> => {
   const intlayerConfig = getConfiguration();
 
-  /**
-   * Format a key to corresponding environment variable name
-   *
-   * Example:
-   *  toEnvVariable('mainDir') => 'INTLAYER_MAIN_DIR'
-   */
-  const formatEnvName = (key: string): string =>
-    prefix + key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+  const prefix = getPrefix(platform);
 
   // Set all configuration values as environment variables
   const env: Record<string, string> = {};
@@ -22,9 +28,9 @@ export const formatEnvVariable = (
     ...intlayerConfig.middleware,
   })) {
     if (typeof value === 'string') {
-      env[formatEnvName(key)] = value;
+      env[formatEnvName(key, prefix)] = value;
     } else {
-      env[formatEnvName(key)] = JSON.stringify(value);
+      env[formatEnvName(key, prefix)] = JSON.stringify(value);
     }
   }
 

package/src/envVariables/getConfiguration.ts

@@ -1,127 +1,99 @@
 import type {
   ContentConfig,
+  DictionaryOutput,
   InternationalizationConfig,
   IntlayerConfig,
   MiddlewareConfig,
   ServerSetCookieRule,
 } from '../types/config';
 import type { Locales } from '../types/locales';
+import { extractEnvVariable } from './extractEnvVariable/index';
 import { getEnvValue } from './utils';
 
-export const intlayerIntlConfiguration: InternationalizationConfig = {
-  locales: getEnvValue<Locales>(
-    process.env.NEXT_PUBLIC_INTLAYER_LOCALES,
-    'array'
-  )!,
-  defaultLocale: getEnvValue<Locales>(
-    process.env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE,
-    'string'
-  )!,
-};
+/**
+ * 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 => {
+  const env = extractEnvVariable();
 
-export const intlayerMiddlewareConfiguration: MiddlewareConfig = {
-  headerName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_HEADER_NAME,
-    'string'
-  )!,
-  cookieName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_COOKIE_NAME,
-    'string'
-  )!,
-  prefixDefault: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_PREFIX_DEFAULT,
-    'boolean'
-  )!,
-  basePath: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_BASE_PATH, 'string')!,
-  serverSetCookie: getEnvValue<ServerSetCookieRule>(
-    process.env.NEXT_PUBLIC_INTLAYER_SERVER_SET_COOKIE,
-    'string'
-  )!,
-  noPrefix: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_NO_PREFIX, 'boolean')!,
-};
+  const intlayerIntlConfiguration: InternationalizationConfig = {
+    locales: getEnvValue<Locales>(env.internationalization.locales, 'array')!,
+    defaultLocale: getEnvValue<Locales>(
+      env?.internationalization.defaultLocale,
+      'string'
+    )!,
+  };
 
-export const intlayerContentConfiguration: ContentConfig = {
-  fileExtensions: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_FILE_EXTENSIONS,
-    'array'
-  )!,
-  baseDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_BASE_DIR, 'string')!,
-  contentDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR_NAME,
-    'string'
-  )!,
-  contentDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR,
-    'string'
-  )!,
-  excludedPath: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_EXCLUDED_PATH,
-    'array'
-  )!,
-  resultDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR_NAME,
-    'string'
-  )!,
-  resultDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR,
-    'string'
-  )!,
-  moduleAugmentationDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
-    'string'
-  )!,
-  moduleAugmentationDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR,
-    'string'
-  )!,
-  bundleDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_DIR_NAME,
-    'string'
-  )!,
-  bundleDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_DIR,
-    'string'
-  )!,
-  bundleFileExtension: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_FILE_EXTENSION,
-    'string'
-  )!,
-  dictionariesDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR_NAME,
-    'string'
-  )!,
-  dictionariesDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR,
-    'string'
-  )!,
-  typeDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_TYPES_DIR_NAME,
-    'string'
-  )!,
-  typesDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_TYPES_DIR, 'string')!,
-  mainDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR_NAME,
-    'string'
-  )!,
-  mainDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR, 'string')!,
-  watchedFilesPattern: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN,
-    'array'
-  )!,
-  watchedFilesPatternWithPath: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
-    'array'
-  )!,
-  outputFilesPatternWithPath: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_OUTPUT_FILES_PATTERN,
-    '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')!,
+  };
 
-export const intlayerConfiguration: IntlayerConfig = {
-  internationalization: intlayerIntlConfiguration,
-  middleware: intlayerMiddlewareConfiguration,
-  content: intlayerContentConfiguration,
-};
+  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,
+  };
 
-export const getConfiguration = (): IntlayerConfig => intlayerConfiguration;
+  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/envVariables/utils.ts

@@ -1,14 +1,32 @@
-function getEnvValue(value: unknown, type: 'boolean'): boolean | undefined;
-function getEnvValue(value: unknown, type: 'number'): number | undefined;
+function getEnvValue(
+  value: unknown,
+  type: 'boolean',
+  verbose?: boolean
+): boolean | undefined;
+function getEnvValue(
+  value: unknown,
+  type: 'number',
+  verbose?: boolean
+): number | undefined;
 function getEnvValue<T extends string>(
   value: unknown,
-  type: 'string'
+  type: 'string',
+  verbose?: boolean
 ): T | undefined;
-function getEnvValue<T>(value: unknown, type: 'object'): T | undefined;
-function getEnvValue<T>(value: unknown, type: 'array'): T[] | undefined;
+function getEnvValue<T>(
+  value: unknown,
+  type: 'object',
+  verbose?: boolean
+): T | undefined;
+function getEnvValue<T>(
+  value: unknown,
+  type: 'array',
+  verbose?: boolean
+): T[] | undefined;
 function getEnvValue(
   value: unknown,
-  type: 'string' | 'boolean' | 'number' | 'object' | 'array'
+  type: 'string' | 'boolean' | 'number' | 'object' | 'array',
+  verbose = false
 ) {
   try {
     switch (type) {
@@ -27,20 +45,18 @@ function getEnvValue(
       case 'object':
       case 'array':
         // Attempt to parse the value as JSON
-        try {
-          return JSON.parse(value as string);
-        } catch (error) {
-          // Log error and return undefined if any error occurs during parsing
-          console.error(`Error parsing environment variable`);
-          return undefined;
-        }
+        return JSON.parse(value as string);
 
       default:
         return undefined;
     }
   } catch (error) {
     // Log error and return undefined if any error occurs during parsing
-    console.error(`Error parsing environment variable`);
+    if (verbose) {
+      console.error(
+        `Error parsing environment variable, parsing : ${((value ?? '') as string).toString()}`
+      );
+    }
     return undefined;
   }
 }

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';