@aidc-toolkit/utility 0.9.6-beta → 0.9.8-beta

package/dist/index.d.ts

@@ -1,61 +1,569 @@
+import { $NormalizeIntoArray, $Dictionary } from './typescript/helpers.js';
+import { DefaultNamespace, FlatNamespace, InitOptions, Namespace, FormatFunction, Resource, TOptions, InterpolationOptions, ResourceLanguage, ResourceKey } from './typescript/options.js';
+import { TFunction, KeyPrefix } from './typescript/t.js';
+import { I18NEnvironment } from '@aidc-toolkit/core';
+import { Resource as Resource$1 } from 'i18next';
+
+// Internal Helpers
+
+
+interface Interpolator {
+  init(options: InterpolationOptions, reset: boolean): undefined;
+  reset(): undefined;
+  resetRegExp(): undefined;
+  interpolate(str: string, data: object, lng: string, options: InterpolationOptions): string;
+  nest(str: string, fc: (...args: any[]) => any, options: InterpolationOptions): string;
+}
+
+declare class ResourceStore {
+  constructor(data: Resource, options: InitOptions);
+
+  public data: Resource;
+
+  public options: InitOptions;
+
+  /**
+   * Gets fired when resources got added or removed
+   */
+  on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
+
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: 'added' | 'removed', callback?: (lng: string, ns: string) => void): void;
+}
+
+interface Formatter {
+  init(services: Services, i18nextOptions: InitOptions): void;
+  add(name: string, fc: (value: any, lng: string | undefined, options: any) => string): void;
+  addCached(
+    name: string,
+    fc: (lng: string | undefined, options: any) => (value: any) => string,
+  ): void;
+  format: FormatFunction;
+}
+
+interface Services {
+  backendConnector: any;
+  i18nFormat: any;
+  interpolator: Interpolator;
+  languageDetector: any;
+  languageUtils: any;
+  logger: any;
+  pluralResolver: any;
+  resourceStore: ResourceStore;
+  formatter?: Formatter;
+}
+
+type ModuleType =
+  | 'backend'
+  | 'logger'
+  | 'languageDetector'
+  | 'postProcessor'
+  | 'i18nFormat'
+  | 'formatter'
+  | '3rdParty';
+
+interface Module {
+  type: ModuleType;
+}
+
+type CallbackError = Error | string | null | undefined;
+type ReadCallback = (
+  err: CallbackError,
+  data: ResourceKey | boolean | null | undefined,
+) => void;
+type MultiReadCallback = (err: CallbackError, data: Resource | null | undefined) => void;
+
 /**
- * Transformer input, one of:
- *
- * - T (primitive type)
- * - Iterable<T>
- *
- * @template T
- * Primitive type.
+ * Used to load data for i18next.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'backend'` For a prototype constructor set static property.
  */
-type TransformerInput<T extends string | number | bigint | boolean> = T | Iterable<T>;
+interface BackendModule<Options = object> extends Module {
+  type: 'backend';
+  init(services: Services, backendOptions: Options, i18nextOptions: InitOptions): void;
+  read(language: string, namespace: string, callback: ReadCallback): void;
+  /** Save the missing translation */
+  create?(
+    languages: readonly string[],
+    namespace: string,
+    key: string,
+    fallbackValue: string,
+  ): void;
+  /** Load multiple languages and namespaces. For backends supporting multiple resources loading */
+  readMulti?(
+    languages: readonly string[],
+    namespaces: readonly string[],
+    callback: MultiReadCallback,
+  ): void;
+  /** Store the translation. For backends acting as cache layer */
+  save?(language: string, namespace: string, data: ResourceLanguage): void;
+}
+
 /**
- * Transformer callback, used to convert transformed value to its final value.
- *
- * @template TInput
- * Type of input to callback.
- *
- * @template TOutput
- * Type of output to callback.
- *
- * @param input
- * Input value.
- *
- * @param index
- * Index in sequence (0 for single transformation).
- *
- * @returns
- * Output value.
+ * Used to detect language in user land.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
  */
-type TransformerCallback<TInput, TOutput> = (input: TInput, index: number) => TOutput;
+interface LanguageDetectorModule extends Module {
+  type: 'languageDetector';
+  init?(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
+  /** Must return detected language */
+  detect(): string | readonly string[] | undefined;
+  cacheUserLanguage?(lng: string): void;
+}
+
 /**
- * Transformer output, based on transformer input:
- *
- * - If type T is primitive type, result is type U.
- * - If type T is Iterable type, result is type IterableIterator<U>.
- *
- * @template T
- * Transformer input type.
- *
- * @template U
- * Output base type.
+ * Used to detect language in user land.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
  */
-type TransformerOutput<T extends TransformerInput<string | number | bigint | boolean>, U> = T extends (T extends TransformerInput<infer V> ? V : never) ? U : IterableIterator<U>;
+interface LanguageDetectorAsyncModule extends Module {
+  type: 'languageDetector';
+  /** Set to true to enable async detection */
+  async: true;
+  init?(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
+  /** Must call callback passing detected language or return a Promise */
+  detect(
+    callback: (lng: string | readonly string[] | undefined) => void | undefined,
+  ): void | Promise<string | readonly string[] | undefined>;
+  cacheUserLanguage?(lng: string): void | Promise<void>;
+}
 
 /**
- * Iterator proxy. In environments where
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helpers |
- * iterator helpers} are supported, this references the {@linkcode Iterator} variable directly. Otherwise, it references
- * an implementation of "from" that uses an internally-defined iterator proxy object.
+ * Override the built-in console logger.
+ * Do not need to be a prototype function.
+ */
+interface LoggerModule extends Module {
+  type: 'logger';
+  log(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+}
+
+interface I18nFormatModule extends Module {
+  type: 'i18nFormat';
+}
+
+interface FormatterModule extends Module, Formatter {
+  type: 'formatter';
+}
+
+interface ThirdPartyModule extends Module {
+  type: '3rdParty';
+  init(i18next: i18n): void;
+}
+
+interface Modules {
+  backend?: BackendModule;
+  logger?: LoggerModule;
+  languageDetector?: LanguageDetectorModule | LanguageDetectorAsyncModule;
+  i18nFormat?: I18nFormatModule;
+  formatter?: FormatterModule;
+  external: ThirdPartyModule[];
+}
+
+// helper to identify class https://stackoverflow.com/a/45983481/2363935
+interface Newable<T> {
+  new (...args: any[]): T;
+}
+interface NewableModule<T extends Module> extends Newable<T> {
+  type: T['type'];
+}
+
+type Callback = (error: any, t: TFunction) => void;
+
+/**
+ * Uses similar args as the t function and returns true if a key exists.
+ */
+interface ExistsFunction<
+  TKeys extends string = string,
+  TInterpolationMap extends object = $Dictionary,
+> {
+  (key: TKeys | TKeys[], options?: TOptions<TInterpolationMap>): boolean;
+}
+
+interface CloneOptions extends InitOptions {
+  /**
+   * Will create a new instance of the resource store and import the existing translation resources.
+   * This way it will not shared the resource store instance.
+   * @default false
+   */
+  forkResourceStore?: boolean;
+}
+
+interface CustomInstanceExtensions {}
+
+// Used just here to exclude `DefaultNamespace` which can be both string or array from `FlatNamespace`
+// in TFunction declaration below.
+// Due to this only very special usage I'm not moving this inside helpers.
+type InferArrayValuesElseReturnType<T> = T extends (infer A)[] ? A : T;
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+interface i18n extends CustomInstanceExtensions {
+  // Expose parameterized t in the i18next interface hierarchy
+  t: TFunction<
+    [
+      ...$NormalizeIntoArray<DefaultNamespace>,
+      ...Exclude<FlatNamespace, InferArrayValuesElseReturnType<DefaultNamespace>>[],
+    ]
+  >;
+
+  /**
+   * The default of the i18next module is an i18next instance ready to be initialized by calling init.
+   * You can create additional instances using the createInstance function.
+   *
+   * @param options - Initial options.
+   * @param callback - will be called after all translations were loaded or with an error when failed (in case of using a backend).
+   */
+  init(callback?: Callback): Promise<TFunction>;
+  init<T>(options: InitOptions<T>, callback?: Callback): Promise<TFunction>;
+
+  loadResources(callback?: (err: any) => void): void;
+
+  /**
+   * The use function is there to load additional plugins to i18next.
+   * For available module see the plugins page and don't forget to read the documentation of the plugin.
+   *
+   * @param module Accepts a class or object
+   */
+  use<T extends Module>(module: T | NewableModule<T> | Newable<T>): this;
+
+  /**
+   * List of modules used
+   */
+  modules: Modules;
+
+  /**
+   * Internal container for all used plugins and implementation details like languageUtils, pluralResolvers, etc.
+   */
+  services: Services;
+
+  /**
+   * Internal container for translation resources
+   */
+  store: ResourceStore;
+
+  /**
+   * Uses similar args as the t function and returns true if a key exists.
+   */
+  exists: ExistsFunction;
+
+  /**
+   * Returns a resource data by language.
+   */
+  getDataByLanguage(lng: string): { [key: string]: { [key: string]: string } } | undefined;
+
+  /**
+   * Returns a t function that defaults to given language or namespace.
+   * Both params could be arrays of languages or namespaces and will be treated as fallbacks in that case.
+   * On the returned function you can like in the t function override the languages or namespaces by passing them in options or by prepending namespace.
+   *
+   * Accepts optional keyPrefix that will be automatically applied to returned t function.
+   */
+  getFixedT<
+    Ns extends Namespace | null = DefaultNamespace,
+    TKPrefix extends KeyPrefix<ActualNs> = undefined,
+    ActualNs extends Namespace = Ns extends null ? DefaultNamespace : Ns,
+  >(
+    ...args:
+      | [lng: string | readonly string[], ns?: Ns, keyPrefix?: TKPrefix]
+      | [lng: null, ns: Ns, keyPrefix?: TKPrefix]
+  ): TFunction<ActualNs, TKPrefix>;
+
+  /**
+   * Changes the language. The callback will be called as soon translations were loaded or an error occurs while loading.
+   * HINT: For easy testing - setting lng to 'cimode' will set t function to always return the key.
+   */
+  changeLanguage(lng?: string, callback?: Callback): Promise<TFunction>;
+
+  /**
+   * Is set to the current detected or set language.
+   * If you need the primary used language depending on your configuration (supportedLngs, load) you will prefer using i18next.languages[0].
+   */
+  language: string;
+
+  /**
+   * Is set to an array of language-codes that will be used it order to lookup the translation value.
+   */
+  languages: readonly string[];
+
+  /**
+   * Is set to the current resolved language.
+   * It can be used as primary used language, for example in a language switcher.
+   */
+  resolvedLanguage?: string;
+
+  /**
+   * Checks if namespace has loaded yet.
+   * i.e. used by react-i18next
+   */
+  hasLoadedNamespace(
+    ns: string | readonly string[],
+    options?: {
+      lng?: string | readonly string[];
+      fallbackLng?: InitOptions['fallbackLng'];
+      /**
+       * if `undefined` is returned default checks are performed.
+       */
+      precheck?: (
+        i18n: i18n,
+        /**
+         * Check if the language namespace provided are not in loading status:
+         * returns `true` if load is completed successfully or with an error.
+         */
+        loadNotPending: (
+          lng: string | readonly string[],
+          ns: string | readonly string[],
+        ) => boolean,
+      ) => boolean | undefined;
+    },
+  ): boolean;
+
+  /**
+   * Loads additional namespaces not defined in init options.
+   */
+  loadNamespaces(ns: string | readonly string[], callback?: Callback): Promise<void>;
+
+  /**
+   * Loads additional languages not defined in init options (preload).
+   */
+  loadLanguages(lngs: string | readonly string[], callback?: Callback): Promise<void>;
+
+  /**
+   * Reloads resources on given state. Optionally you can pass an array of languages and namespaces as params if you don't want to reload all.
+   */
+  reloadResources(
+    lngs?: string | readonly string[],
+    ns?: string | readonly string[],
+    callback?: () => void,
+  ): Promise<void>;
+  reloadResources(lngs: null, ns: string | readonly string[], callback?: () => void): Promise<void>;
+
+  /**
+   * Changes the default namespace.
+   */
+  setDefaultNamespace(ns: string | readonly string[]): void;
+
+  /**
+   * Returns rtl or ltr depending on languages read direction.
+   */
+  dir(lng?: string): 'ltr' | 'rtl';
+
+  /**
+   * Exposes interpolation.format function added on init.
+   */
+  format: FormatFunction;
+
+  /**
+   * Will return a new i18next instance.
+   * Please read the options page for details on configuration options.
+   * Providing a callback will automatically call init.
+   * The callback will be called after all translations were loaded or with an error when failed (in case of using a backend).
+   */
+  createInstance(options?: InitOptions, callback?: Callback): i18n;
+
+  /**
+   * Creates a clone of the current instance. Shares store, plugins and initial configuration.
+   * Can be used to create an instance sharing storage but being independent on set language or namespaces.
+   */
+  cloneInstance(options?: CloneOptions, callback?: Callback): i18n;
+
+  /**
+   * Gets fired after initialization.
+   */
+  on(event: 'initialized', callback: (options: InitOptions) => void): void;
+
+  /**
+   * Gets fired on loaded resources.
+   */
+  on(
+    event: 'loaded',
+    callback: (loaded: { [language: string]: { [namespace: string]: boolean } }) => void,
+  ): void;
+
+  /**
+   * Gets fired if loading resources failed.
+   */
+  on(event: 'failedLoading', callback: (lng: string, ns: string, msg: string) => void): void;
+
+  /**
+   * Gets fired on accessing a key not existing.
+   */
+  on(
+    event: 'missingKey',
+    callback: (lngs: readonly string[], namespace: string, key: string, res: string) => void,
+  ): void;
+
+  /**
+   * Gets fired when resources got added or removed.
+   */
+  on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
+
+  /**
+   * Gets fired when changeLanguage got called.
+   */
+  on(event: 'languageChanged', callback: (lng: string) => void): void;
+
+  /**
+   * Event listener
+   */
+  on(event: string, listener: (...args: any[]) => void): void;
+
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: string, listener?: (...args: any[]) => void): void;
+
+  /**
+   * Gets one value by given key.
+   */
+  getResource(
+    lng: string,
+    ns: string,
+    key: string,
+    options?: Pick<InitOptions, 'keySeparator' | 'ignoreJSONStructure'>,
+  ): any;
+
+  /**
+   * Adds one key/value.
+   */
+  addResource(
+    lng: string,
+    ns: string,
+    key: string,
+    value: string,
+    options?: { keySeparator?: string; silent?: boolean },
+  ): i18n;
+
+  /**
+   * Adds multiple key/values.
+   */
+  addResources(lng: string, ns: string, resources: any): i18n;
+
+  /**
+   * Adds a complete bundle.
+   * Setting deep param to true will extend existing translations in that file.
+   * Setting overwrite to true it will overwrite existing translations in that file.
+   */
+  addResourceBundle(
+    lng: string,
+    ns: string,
+    resources: any,
+    deep?: boolean,
+    overwrite?: boolean,
+  ): i18n;
+
+  /**
+   * Checks if a resource bundle exists.
+   */
+  hasResourceBundle(lng: string, ns: string): boolean;
+
+  /**
+   * Returns a resource bundle.
+   */
+  getResourceBundle(lng: string, ns: string): any;
+
+  /**
+   * Removes an existing bundle.
+   */
+  removeResourceBundle(lng: string, ns: string): i18n;
+
+  /**
+   * Current options
+   */
+  options: InitOptions;
+
+  /**
+   * Is initialized
+   */
+  isInitialized: boolean;
+
+  /**
+   * Is initializing
+   */
+  isInitializing: boolean;
+
+  /**
+   * Store was initialized
+   */
+  initializedStoreOnce: boolean;
+
+  /**
+   * Language was initialized
+   */
+  initializedLanguageOnce: boolean;
+
+  /**
+   * Emit event
+   */
+  emit(eventName: string, ...args: any[]): void;
+}
+
+declare const localeStrings: {
+    readonly Transformer: {
+        readonly domainMustBeGreaterThanZero: "Domain {{domain}} must be greater than 0";
+        readonly tweakMustBeGreaterThanOrEqualToZero: "Tweak {{tweak}} must be greater than or equal to 0";
+        readonly valueMustBeGreaterThanOrEqualToZero: "Value {{value}} must be greater than or equal to 0";
+        readonly valueMustBeLessThan: "Value {{value}} must be less than {{domain}}";
+        readonly minValueMustBeGreaterThanOrEqualToZero: "Minimum value {{minValue}} must be greater than or equal to 0";
+        readonly maxValueMustBeLessThan: "Maximum value {{maxValue}} must be less than {{domain}}";
+    };
+    readonly RegExpValidator: {
+        readonly stringDoesNotMatchPattern: "String {{s}} does not match pattern";
+    };
+    readonly CharacterSetValidator: {
+        readonly firstZeroFirstCharacter: "Character set must support zero as first character";
+        readonly allNumericAllNumericCharacters: "Character set must support all numeric characters in sequence";
+        readonly stringMustNotBeAllNumeric: "String must not be all numeric";
+        readonly lengthMustBeGreaterThanOrEqualTo: "Length {{length}} must be greater than or equal to {{minimumLength}}";
+        readonly lengthMustBeLessThanOrEqualTo: "Length {{length}} must be less than or equal to {{maximumLength}}";
+        readonly lengthMustBeEqualTo: "Length {{length}} must be equal to {{exactLength}}";
+        readonly lengthOfComponentMustBeGreaterThanOrEqualTo: "Length {{length}} of {{component}} must be greater than or equal to {{minimumLength}}";
+        readonly lengthOfComponentMustBeLessThanOrEqualTo: "Length {{length}} of {{component}} must be less than or equal to {{maximumLength}}";
+        readonly lengthOfComponentMustBeEqualTo: "Length {{length}} of {{component}} must be equal to {{exactLength}}";
+        readonly invalidCharacterAtPosition: "Invalid character '{{c}}' at position {{position}}";
+        readonly invalidCharacterAtPositionOfComponent: "Invalid character '{{c}}' at position {{position}} of {{component}}";
+        readonly exclusionNotSupported: "Exclusion value of {{exclusion}} is not supported";
+        readonly invalidTweakWithAllNumericExclusion: "Tweak must not be used with all-numeric exclusion";
+        readonly endSequenceValueMustBeLessThanOrEqualTo: "End sequence value (start sequence value + count - 1) must be less than {{domain}}";
+    };
+    readonly RecordValidator: {
+        readonly typeNameKeyNotFound: "{{typeName}} \"{{key}}\" not found";
+    };
+};
+
+declare const utilityNS = "aidct_utility";
+/**
+ * Locale strings type is extracted from the English locale strings object.
+ */
+type UtilityLocaleStrings = typeof localeStrings;
+/**
+ * Utility resources.
+ */
+declare const utilityResources: Resource$1;
+declare const i18nextUtility: i18n;
+/**
+ * Initialize internationalization.
  *
- * Client applications should **not** rely on long-term availability of this variable as it will be removed once there
- * is widespread support for iterator helpers.
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * Void promise.
  */
-declare const IteratorProxy: Pick<IteratorConstructor, "from">;
+declare function i18nUtilityInit(environment: I18NEnvironment, debug?: boolean): Promise<void>;
 
 /**
- * Sequencer. Defines an ascending or descending sequence of big integers implemented as an iterable iterator.
+ * Sequencer. Defines an ascending or descending sequence of big integers implemented as an iterable.
  */
-declare class Sequencer implements Iterable<bigint>, IterableIterator<bigint> {
+declare class Sequencer implements Iterable<bigint> {
     /**
      * Start value (inclusive).
      */
@@ -80,10 +588,6 @@ declare class Sequencer implements Iterable<bigint>, IterableIterator<bigint> {
      * Maximum value (inclusive).
      */
     private readonly _maxValue;
-    /**
-     * Next value.
-     */
-    private _nextValue;
     /**
      * Constructor.
      *
@@ -118,23 +622,67 @@ declare class Sequencer implements Iterable<bigint>, IterableIterator<bigint> {
     /**
      * Iterable implementation.
      *
-     * @returns
-     * this
+     * @yields
+     * Next value in sequence.
      */
-    [Symbol.iterator](): this;
-    /**
-     * Iterator implementation.
-     *
-     * @returns
-     * Iterator result. If iterator is exhausted, the value is absolute value of the count.
-     */
-    next(): IteratorResult<bigint, number>;
-    /**
-     * Reset the iterator.
-     */
-    reset(): void;
+    [Symbol.iterator](): Generator<bigint>;
 }
 
+/**
+ * Transformer input, one of:
+ *
+ * - T (primitive type)
+ * - Iterable<T>
+ *
+ * @template T
+ * Primitive type.
+ */
+type TransformerInput<T extends string | number | bigint | boolean> = T | Iterable<T>;
+/**
+ * Transformer callback, used to convert transformed value to its final value.
+ *
+ * @template TInput
+ * Type of input to callback.
+ *
+ * @template TOutput
+ * Type of output to callback.
+ *
+ * @param input
+ * Input value.
+ *
+ * @param index
+ * Index in sequence (0 for single transformation).
+ *
+ * @returns
+ * Output value.
+ */
+type TransformerCallback<TInput, TOutput> = (input: TInput, index: number) => TOutput;
+/**
+ * Transformer output, based on transformer input:
+ *
+ * - If type T is primitive, result is type TOutput.
+ * - If type T is Iterable, result is type Iterable<TOutput>.
+ *
+ * @template T
+ * Transformer input type.
+ *
+ * @template TOutput
+ * Output base type.
+ */
+type TransformerOutput<T extends TransformerInput<string | number | bigint | boolean>, TOutput> = T extends (T extends TransformerInput<infer TInput> ? TInput : never) ? TOutput : Iterable<TOutput>;
+/**
+ * Transform an iterable by applying a transformer callback to each entry.
+ *
+ * @param iterable
+ * Input iterable.
+ *
+ * @param transformerCallback
+ * Callback to transform input value to output value.
+ *
+ * @returns
+ * Output iterable.
+ */
+declare function transformIterable<TInput, TOutput>(iterable: Iterable<TInput>, transformerCallback: TransformerCallback<TInput, TOutput>): Iterable<TOutput>;
 /**
  * Transformer that transforms values in a numeric domain to values in a range equal to the domain or to another range
  * defined by a callback function. In other words, the domain determines valid input values and, without a callback, the
@@ -837,4 +1385,4 @@ declare const ALPHABETIC_CREATOR: CharacterSetCreator;
  */
 declare const ALPHANUMERIC_CREATOR: CharacterSetCreator;
 
-export { ALPHABETIC_CREATOR, ALPHANUMERIC_CREATOR, CharacterSetCreator, type CharacterSetValidation, CharacterSetValidator, EncryptionTransformer, Exclusion, HEXADECIMAL_CREATOR, IdentityTransformer, IteratorProxy, NUMERIC_CREATOR, RecordValidator, RegExpValidator, Sequencer, type StringValidation, type StringValidator, Transformer, type TransformerCallback, type TransformerInput, type TransformerOutput };
+export { ALPHABETIC_CREATOR, ALPHANUMERIC_CREATOR, CharacterSetCreator, type CharacterSetValidation, CharacterSetValidator, EncryptionTransformer, Exclusion, HEXADECIMAL_CREATOR, IdentityTransformer, NUMERIC_CREATOR, RecordValidator, RegExpValidator, Sequencer, type StringValidation, type StringValidator, Transformer, type TransformerCallback, type TransformerInput, type TransformerOutput, type UtilityLocaleStrings, i18nUtilityInit, i18nextUtility, transformIterable, utilityNS, utilityResources };