@softkit/i18n
Version:
This library is a simple wrapper based on [nestjs-i18n](https://nestjs-i18n.com/)
240 lines • 9.77 kB
JavaScript
;
var I18nModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.I18nModule = exports.logger = void 0;
const tslib_1 = require("tslib");
const common_1 = require("@nestjs/common");
const i18n_constants_1 = require("./i18n.constants");
const i18n_service_1 = require("./services/i18n.service");
const i18n_language_interceptor_1 = require("./interceptors/i18n-language.interceptor");
const core_1 = require("@nestjs/core");
const i18n_resolver_options_decorator_1 = require("./decorators/i18n-resolver-options.decorator");
const util_1 = require("./utils/util");
const string_format_1 = tslib_1.__importDefault(require("string-format"));
const i18n_middleware_1 = require("./middlewares/i18n.middleware");
const loaders_utils_1 = require("./utils/loaders-utils");
const type_guards_1 = require("./utils/type-guards");
exports.logger = new common_1.Logger('I18nService');
const defaultOptions = {
resolvers: [],
formatter: string_format_1.default,
logging: true,
throwOnMissingKey: false,
};
let I18nModule = I18nModule_1 = class I18nModule {
constructor(i18n, i18nOptions, adapter) {
this.i18n = i18n;
this.i18nOptions = i18nOptions;
this.adapter = adapter;
}
static forRoot(options) {
options = this.sanitizeI18nOptions(options);
const i18nOptions = {
provide: i18n_constants_1.I18N_OPTIONS,
useValue: options,
};
const i18nLoaderProvider = {
provide: i18n_constants_1.I18N_LOADERS,
useValue: options.loaders,
};
const translationsProvider = {
provide: i18n_constants_1.I18N_TRANSLATIONS,
useFactory: async (loaders) => {
return (0, loaders_utils_1.processTranslations)(loaders);
},
inject: [i18n_constants_1.I18N_LOADERS],
};
const languagesProvider = {
provide: i18n_constants_1.I18N_LANGUAGES,
useFactory: async (loaders) => {
return (0, loaders_utils_1.processLanguages)(loaders);
},
inject: [i18n_constants_1.I18N_LOADERS],
};
const resolversProvider = {
provide: i18n_constants_1.I18N_RESOLVERS,
useValue: options.resolvers || [],
};
return {
module: I18nModule_1,
providers: [
{ provide: common_1.Logger, useValue: exports.logger },
{
provide: core_1.APP_INTERCEPTOR,
useClass: i18n_language_interceptor_1.I18nLanguageInterceptor,
},
i18n_service_1.I18nService,
i18nOptions,
translationsProvider,
languagesProvider,
resolversProvider,
i18nLoaderProvider,
...this.createResolverProviders(options.resolvers),
],
exports: [i18n_constants_1.I18N_OPTIONS, i18n_constants_1.I18N_RESOLVERS, i18n_service_1.I18nService, languagesProvider],
};
}
static forRootAsync(options) {
options = this.sanitizeI18nOptions(options);
const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
const asyncTranslationProvider = this.createAsyncTranslationProvider();
const asyncLanguagesProvider = this.createAsyncLanguagesProvider();
const asyncLoadersProvider = this.createAsyncLoadersProvider();
const resolversProvider = {
provide: i18n_constants_1.I18N_RESOLVERS,
useValue: options.resolvers || [],
};
return {
module: I18nModule_1,
imports: options.imports || [],
providers: [
{ provide: common_1.Logger, useValue: exports.logger },
{
provide: core_1.APP_INTERCEPTOR,
useClass: i18n_language_interceptor_1.I18nLanguageInterceptor,
},
asyncOptionsProvider,
asyncTranslationProvider,
asyncLanguagesProvider,
i18n_service_1.I18nService,
resolversProvider,
asyncLoadersProvider,
...this.createResolverProviders(options.resolvers),
],
exports: [
i18n_constants_1.I18N_OPTIONS,
i18n_constants_1.I18N_RESOLVERS,
i18n_constants_1.I18N_LOADERS,
i18n_service_1.I18nService,
asyncLanguagesProvider,
],
};
}
static createAsyncLoadersProvider() {
return {
provide: i18n_constants_1.I18N_LOADERS,
useFactory: async (options) => {
return options.loaders;
},
inject: [i18n_constants_1.I18N_OPTIONS],
};
}
static createAsyncOptionsProvider(options) {
if (options.useFactory) {
const factory = options.useFactory;
return {
provide: i18n_constants_1.I18N_OPTIONS,
useFactory: async (...args) => {
const resolvers = await factory(...args);
return this.sanitizeI18nOptions(resolvers);
},
inject: options.inject || [],
};
}
const existingOrClass = options.useClass || options.useExisting;
if (existingOrClass) {
return {
provide: i18n_constants_1.I18N_OPTIONS,
useFactory: async (optionsFactory) => this.sanitizeI18nOptions((await optionsFactory.createI18nOptions())),
inject: [existingOrClass],
};
}
throw new Error('Invalid I18n async options, useClass or useExisting or useFactory must be provided');
}
static createAsyncTranslationProvider() {
return {
provide: i18n_constants_1.I18N_TRANSLATIONS,
useFactory: async (loaders) => {
return (0, loaders_utils_1.processTranslations)(loaders);
},
inject: [i18n_constants_1.I18N_LOADERS],
};
}
static createAsyncLanguagesProvider() {
return {
provide: i18n_constants_1.I18N_LANGUAGES,
useFactory: async (loaders) => {
return (0, loaders_utils_1.processLanguages)(loaders);
},
inject: [i18n_constants_1.I18N_LOADERS],
};
}
static sanitizeI18nOptions(options) {
options = { ...defaultOptions, ...options };
return options;
}
static createResolverProviders(resolvers) {
if (!resolvers || resolvers.length === 0) {
exports.logger.error(`No resolvers provided! @softkit/i18n won't work properly, please follow the quick-start guide: https://docs.softkit.dev/libraries/i18n/quick-start`);
}
return (resolvers || [])
.filter(util_1.shouldResolve)
.reduce((providers, r) => {
if ((0, type_guards_1.isResolverWithOptions)(r)) {
const { use: resolver, options, ...rest } = r;
const optionsToken = (0, i18n_resolver_options_decorator_1.getI18nResolverOptionsToken)(resolver);
providers.push({
provide: resolver,
useClass: resolver,
});
if (options) {
rest.useValue = options;
}
providers.push({
provide: optionsToken,
...rest,
});
}
else {
const optionsToken = (0, i18n_resolver_options_decorator_1.getI18nResolverOptionsToken)(r);
providers.push({
provide: r,
useClass: r,
inject: [optionsToken],
}, {
provide: optionsToken,
useFactory: () => { },
});
}
return providers;
}, []);
}
async onModuleInit() {
// makes sure languages & translations are loaded before application loads
await this.i18n.refresh();
// Register handlebars helper
if (this.i18nOptions.viewEngine == 'hbs') {
try {
const hbs = (await Promise.resolve().then(() => tslib_1.__importStar(require('hbs')))).default;
hbs.registerHelper('t', this.i18n.hbsHelper);
exports.logger.log('Handlebars helper registered');
}
catch (error) {
exports.logger.error('hbs module failed to load', error);
}
}
if (this.i18nOptions.viewEngine &&
['pug', 'ejs'].includes(this.i18nOptions.viewEngine)) {
const app = this.adapter.httpAdapter.getInstance();
app.locals['t'] = (key, lang, args) => {
return this.i18n.t(key, { lang, args });
};
}
}
configure(consumer) {
if (this.i18nOptions.disableMiddleware)
return;
const nestMiddleware = (0, util_1.isNestMiddleware)(consumer);
consumer
.apply(i18n_middleware_1.I18nMiddleware)
.forRoutes(nestMiddleware && (0, util_1.usingFastify)(consumer) ? '(.*)' : '*');
}
};
exports.I18nModule = I18nModule;
exports.I18nModule = I18nModule = I18nModule_1 = tslib_1.__decorate([
(0, common_1.Global)(),
(0, common_1.Module)({}),
tslib_1.__param(1, (0, common_1.Inject)(i18n_constants_1.I18N_OPTIONS)),
tslib_1.__metadata("design:paramtypes", [i18n_service_1.I18nService, Object, core_1.HttpAdapterHost])
], I18nModule);
//# sourceMappingURL=i18n.module.js.map