11386416919

Committed 17 Oct 2024 01:53PM UTC coverage: 90.821% (+0.02%) from 90.805%

Build # 11386416919

Build Type

push

github

Committed by

web-flow

Commit Message

build: check format & lint in GitHub workflow (#670)

Run Details

240 of 286 branches covered (83.92%)

Branch coverage included in aggregate %.

7 of 8 new or added lines in 4 files covered. (87.5%)

1 existing line in 1 file now uncovered.

789 of 847 relevant lines covered (93.15%)

104.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.61

/src/services/i18n.service.ts

import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import { validate } from 'class-validator';
import {
  BehaviorSubject,
  Observable,
  Subject,
  lastValueFrom,
  take,
  takeUntil,
} from 'rxjs';
import {
  I18nContext,
  I18nOptions,
  I18nTranslation,
  I18nValidationError,
} from '..';
import {
  I18N_LANGUAGES,
  I18N_LANGUAGES_SUBJECT,
  I18N_OPTIONS,
  I18N_TRANSLATIONS,
  I18N_TRANSLATIONS_SUBJECT,
} from '../i18n.constants';
import { I18nLoader } from '../loaders/i18n.loader';
import { IfAnyOrNever, Path, PathValue } from '../types';
import { formatI18nErrors } from '../utils';
import { I18nTranslator, I18nPluralObject } from '../interfaces';
import { I18nError } from '../i18n.error';

const pluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other'];

export type TranslateOptions = {
  lang?: string;
  args?: ({ [k: string]: any } | string)[] | { [k: string]: any };
  defaultValue?: string;
  debug?: boolean;
};

@Injectable()
export class I18nService<K = Record<string, unknown>>
  implements I18nTranslator<K>, OnModuleDestroy
{
  private supportedLanguages: string[];
  private translations: I18nTranslation;
  private pluralRules = new Map<string, Intl.PluralRules>();

  private unsubscribe = new Subject<void>();

  constructor(
    @Inject(I18N_OPTIONS)
    protected readonly i18nOptions: I18nOptions,
    @Inject(I18N_TRANSLATIONS)
    translations: Observable<I18nTranslation>,
    @Inject(I18N_LANGUAGES)
    supportedLanguages: Observable<string[]>,
    private readonly logger: Logger,
    private readonly loader: I18nLoader,
    @Inject(I18N_LANGUAGES_SUBJECT)
    private readonly languagesSubject: BehaviorSubject<string[]>,
    @Inject(I18N_TRANSLATIONS_SUBJECT)
    private readonly translationsSubject: BehaviorSubject<I18nTranslation>,
  ) {
    supportedLanguages
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((languages) => {
        this.supportedLanguages = languages;
      });
    translations.pipe(takeUntil(this.unsubscribe)).subscribe((t) => {
      this.translations = t;
    });
  }

  public onModuleDestroy(): void {
    this.unsubscribe.next(null);
    this.unsubscribe.complete();
  }

  public translate<P extends Path<K> = any, R = PathValue<K, P>>(
    key: P,
    options?: TranslateOptions,
  ): IfAnyOrNever<R, string, R> {
    options = {
      lang: I18nContext.current()?.lang || this.i18nOptions.fallbackLanguage,
      ...options,
    };

    const { defaultValue } = options;
    let { lang } = options;

    if (lang === 'debug') {
      return key as unknown as IfAnyOrNever<R, string, R>;
    }

    const previousFallbackLang = lang;

    lang = lang ?? this.i18nOptions.fallbackLanguage;

    lang = this.resolveLanguage(lang);

    const translationsByLanguage = this.translations[lang];

    const translation = this.translateObject(
      key as string,
      (translationsByLanguage ?? key) as string,
      lang,
      options,
      translationsByLanguage,
    );

    if (translationsByLanguage == null || !translation) {
      const translationKeyMissing = `Translation "${
        key as string
      }" in "${lang}" does not exist.`;
      if (lang !== this.i18nOptions.fallbackLanguage || !!defaultValue) {
        if (this.i18nOptions.logging && this.i18nOptions.throwOnMissingKey) {
          this.logger.error(translationKeyMissing);
          throw new I18nError(translationKeyMissing);
        }

        const nextFallbackLanguage = this.getFallbackLanguage(lang);

        if (previousFallbackLang !== nextFallbackLanguage) {
          return this.translate(key, {
            ...options,
            lang: nextFallbackLanguage,
          });
        }
      }
    }

    return (translation ?? key) as unknown as IfAnyOrNever<R, string, R>;
  }

  private getFallbackLanguage(lang: string) {
    let regionSepIndex = -1;

    if (lang.includes('-')) {
      regionSepIndex = lang.lastIndexOf('-');
    }

    if (lang.includes('_')) {
      regionSepIndex = lang.lastIndexOf('_');
    }

    return regionSepIndex !== -1
      ? lang.slice(0, regionSepIndex)
      : this.i18nOptions.fallbackLanguage;
  }

  public t<P extends Path<K> = any, R = PathValue<K, P>>(
    key: P,
    options?: TranslateOptions,
  ): IfAnyOrNever<R, string, R> {
    return this.translate(key, options);
  }

  public getSupportedLanguages() {
    return this.supportedLanguages;
  }

  public getTranslations() {
    return this.translations;
  }

  public async refresh(
    translations?: I18nTranslation | Observable<I18nTranslation>,
    languages?: string[] | Observable<string[]>,
  ) {
    if (!translations) {
      translations = await this.loader.load();
    }
    if (translations instanceof Observable) {
      this.translationsSubject.next(
        await lastValueFrom(translations.pipe(take(1))),
      );
    } else {
      this.translationsSubject.next(translations);
    }

    if (!languages) {
      languages = await this.loader.languages();
    }

    if (languages instanceof Observable) {
      this.languagesSubject.next(await lastValueFrom(languages.pipe(take(1))));
    } else {
      this.languagesSubject.next(languages);
    }
  }

  public hbsHelper = <P extends Path<K> = any>(
    key: P,
    args: any,
    options: any,
  ) => {
    if (!options) {
      options = args;
    }

    const lang = options.lookupProperty(options.data.root, 'i18nLang');
    return this.t<P>(key, { lang, args });
  };

  private translateObject(
    key: string,
    translations: I18nTranslation | string,
    lang: string,
    options?: TranslateOptions,
    rootTranslations?: I18nTranslation | string,
  ): I18nTranslation | string {
    const keys = key.split('.');
    const [firstKey] = keys;

    const args = options?.args;

    if (keys.length > 1 && !translations[key]) {
      const newKey = keys.slice(1, keys.length).join('.');

      if (translations && translations[firstKey]) {
        return this.translateObject(
          newKey,
          translations[firstKey],
          lang,
          options,
          rootTranslations,
        );
      }
    }

    let translation = translations[key] ?? options?.defaultValue;

    if (translation && (args || (args instanceof Array && args.length > 0))) {
      const pluralObject = this.getPluralObject(translation);
      if (pluralObject && args && args['count'] !== undefined) {
        const count = Number(args['count']);

        if (!this.pluralRules.has(lang)) {
          this.pluralRules.set(lang, new Intl.PluralRules(lang));
        }

        const pluralRules = this.pluralRules.get(lang);
        const pluralCategory = pluralRules.select(count);

        if (count === 0 && pluralObject['zero']) {
          translation = pluralObject['zero'];
        } else if (pluralObject[pluralCategory]) {
          translation = pluralObject[pluralCategory];
        }
      } else if (translation instanceof Object) {
        const result = Object.keys(translation).reduce((obj, nestedKey) => {
          return {
            ...obj,
            [nestedKey]: this.translateObject(
              nestedKey,
              translation,
              lang,
              options,
              rootTranslations,
            ),
          };
        }, {});

        if (translation instanceof Array) {
          return Object.values(result) as unknown as I18nTranslation;
        }

        return result;
      }
      translation = this.i18nOptions.formatter(
        translation,
        ...(args instanceof Array ? args || [] : [args]),
      );
      const nestedTranslations = this.getNestedTranslations(translation);
      if (nestedTranslations && nestedTranslations.length > 0) {
        let offset = 0;
        for (const nestedTranslation of nestedTranslations) {
          const result = rootTranslations
            ? (this.translateObject(
                nestedTranslation.key,
                rootTranslations,
                lang,
                {
                  ...options,
                  args: { parent: options.args, ...nestedTranslation.args },
                },
              ) as string) ?? ''
            : '';
          translation =
            translation.substring(0, nestedTranslation.index - offset) +
            result +
            translation.substring(
              nestedTranslation.index + nestedTranslation.length - offset,
            );
          offset = offset + (nestedTranslation.length - result.length);
        }
      }
    }

    return translation;
  }

  public resolveLanguage(lang: string) {
    if (this.i18nOptions.fallbacks && !this.supportedLanguages.includes(lang)) {
      const sanitizedLang = lang.includes('-')
        ? lang.substring(0, lang.indexOf('-')).concat('-*')
        : lang;

      for (const key in this.i18nOptions.fallbacks) {
        if (key === lang || key === sanitizedLang) {
          lang = this.i18nOptions.fallbacks[key];
          break;
        }
      }
    }
    return lang;
  }

  private getPluralObject(translation: any): I18nPluralObject | undefined {
    for (const k of pluralKeys) {
      if (translation[k]) {
        return translation as I18nPluralObject;
      }
    }

    return undefined;
  }

  private getNestedTranslations(
    translation: string,
  ): { index: number; length: number; key: string; args: any }[] | undefined {
    const list = [];
    const regex = /\$t\((.*?)(,(.*?))?\)/g;
    let result: RegExpExecArray;
    while ((result = regex.exec(translation))) {
      let key = undefined;
      let args = {};
      let index = undefined;
      let length = undefined;
      if (result && result.length > 0) {
        key = result[1].trim();
        index = result.index;
        length = result[0].length;
        if (result.length >= 3 && result[3]) {
          try {
            args = JSON.parse(result[3]);
          } catch (e) {
            this.logger.error(`Error while parsing JSON`, e);
          }
        }
      }
      if (key) {
        list.push({ index, length, key, args });
      }
      result = undefined;
    }

    return list.length > 0 ? list : undefined;
  }

  public async validate(
    value: any,
    options?: TranslateOptions,
  ): Promise<I18nValidationError[]> {
    const errors = await validate(value, this.i18nOptions.validatorOptions);
    return formatI18nErrors(errors, this, options);
  }
}

1	import { Inject, Injectable, Logger, OnModuleDestroy } from '@nestjs/common';	14✔
2	import { validate } from 'class-validator';	14✔
3	import {	14✔
4	BehaviorSubject,
5	Observable,
6	Subject,
7	lastValueFrom,
8	take,
9	takeUntil,
10	} from 'rxjs';
11	import {	14✔
12	I18nContext,
13	I18nOptions,
14	I18nTranslation,
15	I18nValidationError,
16	} from '..';
17	import {	14✔
18	I18N_LANGUAGES,
19	I18N_LANGUAGES_SUBJECT,
20	I18N_OPTIONS,
21	I18N_TRANSLATIONS,
22	I18N_TRANSLATIONS_SUBJECT,
23	} from '../i18n.constants';
24	import { I18nLoader } from '../loaders/i18n.loader';	14✔
25	import { IfAnyOrNever, Path, PathValue } from '../types';
26	import { formatI18nErrors } from '../utils';	14✔
27	import { I18nTranslator, I18nPluralObject } from '../interfaces';
28	import { I18nError } from '../i18n.error';	14✔
29
30	const pluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other'];	14✔
31
32	export type TranslateOptions = {
33	lang?: string;
34	args?: ({ [k: string]: any } \| string)[] \| { [k: string]: any };
35	defaultValue?: string;
36	debug?: boolean;
37	};
38
39	@Injectable()
40	export class I18nService<K = Record<string, unknown>>	14✔
41	implements I18nTranslator<K>, OnModuleDestroy
42	{
43	private supportedLanguages: string[];
44	private translations: I18nTranslation;
45	private pluralRules = new Map<string, Intl.PluralRules>();	21✔
46
47	private unsubscribe = new Subject<void>();	21✔
48
49	constructor(
50	@Inject(I18N_OPTIONS)
51	protected readonly i18nOptions: I18nOptions,	21✔
52	@Inject(I18N_TRANSLATIONS)
53	translations: Observable<I18nTranslation>,
54	@Inject(I18N_LANGUAGES)
55	supportedLanguages: Observable<string[]>,
56	private readonly logger: Logger,	21✔
57	private readonly loader: I18nLoader,	21✔
58	@Inject(I18N_LANGUAGES_SUBJECT)
59	private readonly languagesSubject: BehaviorSubject<string[]>,	21✔
60	@Inject(I18N_TRANSLATIONS_SUBJECT)
61	private readonly translationsSubject: BehaviorSubject<I18nTranslation>,	21✔
62	) {
63	supportedLanguages	21✔
64	.pipe(takeUntil(this.unsubscribe))
65	.subscribe((languages) => {
66	this.supportedLanguages = languages;	35✔
67	});
68	translations.pipe(takeUntil(this.unsubscribe)).subscribe((t) => {	21✔
69	this.translations = t;	35✔
70	});
71	}
72
73	public onModuleDestroy(): void {
74	this.unsubscribe.next(null);	10✔
75	this.unsubscribe.complete();	10✔
76	}
77
78	public translate<P extends Path<K> = any, R = PathValue<K, P>>(
79	key: P,
80	options?: TranslateOptions,
81	): IfAnyOrNever<R, string, R> {
82	options = {	388✔
83	lang: I18nContext.current()?.lang \|\| this.i18nOptions.fallbackLanguage,	471✔
84	...options,
85	};
86
87	const { defaultValue } = options;	388✔
88	let { lang } = options;	388✔
89
90	if (lang === 'debug') {	388✔
91	return key as unknown as IfAnyOrNever<R, string, R>;	1✔
92	}
93
94	const previousFallbackLang = lang;	387✔
95
96	lang = lang ?? this.i18nOptions.fallbackLanguage;	387!
97
98	lang = this.resolveLanguage(lang);	387✔
99
100	const translationsByLanguage = this.translations[lang];	387✔
101
102	const translation = this.translateObject(	387✔
103	key as string,
104	(translationsByLanguage ?? key) as string,	394✔
105	lang,
106	options,
107	translationsByLanguage,
108	);
109
110	if (translationsByLanguage == null \|\| !translation) {	387✔
111	const translationKeyMissing = `Translation "${	22✔
112	key as string
113	}" in "${lang}" does not exist.`;
114	if (lang !== this.i18nOptions.fallbackLanguage \|\| !!defaultValue) {	22✔
115	if (this.i18nOptions.logging && this.i18nOptions.throwOnMissingKey) {	11!
UNCOV 116	this.logger.error(translationKeyMissing);	×
117	throw new I18nError(translationKeyMissing);	×
118	}
119
120	const nextFallbackLanguage = this.getFallbackLanguage(lang);	11✔
121
122	if (previousFallbackLang !== nextFallbackLanguage) {	11✔
123	return this.translate(key, {	9✔
124	...options,
125	lang: nextFallbackLanguage,
126	});
127	}
128	}
129	}
130
131	return (translation ?? key) as unknown as IfAnyOrNever<R, string, R>;	378✔
132	}
133
134	private getFallbackLanguage(lang: string) {
135	let regionSepIndex = -1;	11✔
136
137	if (lang.includes('-')) {	11✔
138	regionSepIndex = lang.lastIndexOf('-');	6✔
139	}
140
141	if (lang.includes('_')) {	11✔
142	regionSepIndex = lang.lastIndexOf('_');	2✔
143	}
144
145	return regionSepIndex !== -1	11✔
146	? lang.slice(0, regionSepIndex)
147	: this.i18nOptions.fallbackLanguage;
148	}
149
150	public t<P extends Path<K> = any, R = PathValue<K, P>>(
151	key: P,
152	options?: TranslateOptions,
153	): IfAnyOrNever<R, string, R> {
154	return this.translate(key, options);	42✔
155	}
156
157	public getSupportedLanguages() {
158	return this.supportedLanguages;	30✔
159	}
160
161	public getTranslations() {
162	return this.translations;	3✔
163	}
164
165	public async refresh(
166	translations?: I18nTranslation \| Observable<I18nTranslation>,
167	languages?: string[] \| Observable<string[]>,
168	) {
169	if (!translations) {	13✔
170	translations = await this.loader.load();	13✔
171	}
172	if (translations instanceof Observable) {	13!
173	this.translationsSubject.next(	×
174	await lastValueFrom(translations.pipe(take(1))),
175	);
176	} else {
177	this.translationsSubject.next(translations);	13✔
178	}
179
180	if (!languages) {	13✔
181	languages = await this.loader.languages();	13✔
182	}
183
184	if (languages instanceof Observable) {	13!
185	this.languagesSubject.next(await lastValueFrom(languages.pipe(take(1))));	×
186	} else {
187	this.languagesSubject.next(languages);	13✔
188	}
189	}
190
191	public hbsHelper = <P extends Path<K> = any>(	21✔
192	key: P,
193	args: any,
194	options: any,
195	) => {
196	if (!options) {	4✔
197	options = args;	2✔
198	}
199
200	const lang = options.lookupProperty(options.data.root, 'i18nLang');	4✔
201	return this.t<P>(key, { lang, args });	4✔
202	};
203
204	private translateObject(
205	key: string,
206	translations: I18nTranslation \| string,
207	lang: string,
208	options?: TranslateOptions,
209	rootTranslations?: I18nTranslation \| string,
210	): I18nTranslation \| string {
211	const keys = key.split('.');	870✔
212	const [firstKey] = keys;	870✔
213
214	const args = options?.args;	870✔
215
216	if (keys.length > 1 && !translations[key]) {	870✔
217	const newKey = keys.slice(1, keys.length).join('.');	447✔
218
219	if (translations && translations[firstKey]) {	447✔
220	return this.translateObject(	438✔
221	newKey,
222	translations[firstKey],
223	lang,
224	options,
225	rootTranslations,
226	);
227	}
228	}
229
230	let translation = translations[key] ?? options?.defaultValue;	432✔
231
232	if (translation && (args \|\| (args instanceof Array && args.length > 0))) {	432!
233	const pluralObject = this.getPluralObject(translation);	191✔
234	if (pluralObject && args && args['count'] !== undefined) {	191✔
235	const count = Number(args['count']);	34✔
236
237	if (!this.pluralRules.has(lang)) {	34✔
238	this.pluralRules.set(lang, new Intl.PluralRules(lang));	13✔
239	}
240
241	const pluralRules = this.pluralRules.get(lang);	34✔
242	const pluralCategory = pluralRules.select(count);	34✔
243
244	if (count === 0 && pluralObject['zero']) {	34✔
245	translation = pluralObject['zero'];	5✔
246	} else if (pluralObject[pluralCategory]) {	29✔
247	translation = pluralObject[pluralCategory];	29✔
248	}
249	} else if (translation instanceof Object) {	157✔
250	const result = Object.keys(translation).reduce((obj, nestedKey) => {	2✔
251	return {	6✔
252	...obj,
253	[nestedKey]: this.translateObject(
254	nestedKey,
255	translation,
256	lang,
257	options,
258	rootTranslations,
259	),
260	};
261	}, {});
262
263	if (translation instanceof Array) {	2!
264	return Object.values(result) as unknown as I18nTranslation;	×
265	}
266
267	return result;	2✔
268	}
269	translation = this.i18nOptions.formatter(	189✔
270	translation,
271	...(args instanceof Array ? args \|\| [] : [args]),	191!
272	);
273	const nestedTranslations = this.getNestedTranslations(translation);	189✔
274	if (nestedTranslations && nestedTranslations.length > 0) {	189✔
275	let offset = 0;	40✔
276	for (const nestedTranslation of nestedTranslations) {	40✔
277	const result = rootTranslations	40✔
278	? (this.translateObject(	39!
279	nestedTranslation.key,
280	rootTranslations,
281	lang,
282	{
283	...options,
284	args: { parent: options.args, ...nestedTranslation.args },
285	},
286	) as string) ?? ''
287	: '';
288	translation =	40✔
289	translation.substring(0, nestedTranslation.index - offset) +
290	result +
291	translation.substring(
292	nestedTranslation.index + nestedTranslation.length - offset,
293	);
294	offset = offset + (nestedTranslation.length - result.length);	40✔
295	}
296	}
297	}
298
299	return translation;	430✔
300	}
301
302	public resolveLanguage(lang: string) {
303	if (this.i18nOptions.fallbacks && !this.supportedLanguages.includes(lang)) {	387✔
304	const sanitizedLang = lang.includes('-')	57✔
305	? lang.substring(0, lang.indexOf('-')).concat('-*')
306	: lang;
307
308	for (const key in this.i18nOptions.fallbacks) {	57✔
309	if (key === lang \|\| key === sanitizedLang) {	164✔
310	lang = this.i18nOptions.fallbacks[key];	54✔
311	break;	54✔
312	}
313	}
314	}
315	return lang;	387✔
316	}
317
318	private getPluralObject(translation: any): I18nPluralObject \| undefined {
319	for (const k of pluralKeys) {	191✔
320	if (translation[k]) {	985✔
321	return translation as I18nPluralObject;	34✔
322	}
323	}
324
325	return undefined;	157✔
326	}
327
328	private getNestedTranslations(
329	translation: string,
330	): { index: number; length: number; key: string; args: any }[] \| undefined {
331	const list = [];	189✔
332	const regex = /\$t\((.?)(,(.?))?\)/g;	189✔
333	let result: RegExpExecArray;
334	while ((result = regex.exec(translation))) {	189✔
335	let key = undefined;	40✔
336	let args = {};	40✔
337	let index = undefined;	40✔
338	let length = undefined;	40✔
339	if (result && result.length > 0) {	40✔
340	key = result[1].trim();	40✔
341	index = result.index;	40✔
342	length = result[0].length;	40✔
343	if (result.length >= 3 && result[3]) {	40✔
344	try {	8✔
345	args = JSON.parse(result[3]);	8✔
346	} catch (e) {
347	this.logger.error(`Error while parsing JSON`, e);	×
348	}
349	}
350	}
351	if (key) {	40✔
352	list.push({ index, length, key, args });	40✔
353	}
354	result = undefined;	40✔
355	}
356
357	return list.length > 0 ? list : undefined;	189✔
358	}
359
360	public async validate(
361	value: any,
362	options?: TranslateOptions,
363	): Promise<I18nValidationError[]> {
364	const errors = await validate(value, this.i18nOptions.validatorOptions);	1✔
365	return formatI18nErrors(errors, this, options);	1✔
366	}
367	}

toonvanstrijp / nestjs-i18n / 11386416919

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous