@harpy-js/core 0.4.7

package/dist/i18n/__tests__/i18n.service.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const i18n_service_1 = require("../i18n.service");
+const i18n_module_options_1 = require("../i18n-module.options");
+const core_1 = require("@nestjs/core");
+describe("I18nService", () => {
+    let service;
+    const mockOptions = {
+        defaultLocale: "en",
+        locales: ["en", "fr"],
+        urlPattern: "query",
+        translationsPath: "./dictionaries",
+        cookieName: "locale",
+        queryParam: "lang",
+    };
+    const mockRequest = {
+        locale: "en",
+    };
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            providers: [
+                i18n_service_1.I18nService,
+                {
+                    provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                    useValue: mockOptions,
+                },
+                {
+                    provide: core_1.REQUEST,
+                    useValue: mockRequest,
+                },
+            ],
+        }).compile();
+        service = await module.resolve(i18n_service_1.I18nService);
+    });
+    describe("getLocale", () => {
+        it("should return locale from request", () => {
+            expect(service.getLocale()).toBe("en");
+        });
+        it("should return default locale when request locale is not set", async () => {
+            const requestWithoutLocale = {};
+            const module = await testing_1.Test.createTestingModule({
+                providers: [
+                    i18n_service_1.I18nService,
+                    {
+                        provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                        useValue: mockOptions,
+                    },
+                    {
+                        provide: core_1.REQUEST,
+                        useValue: requestWithoutLocale,
+                    },
+                ],
+            }).compile();
+            const serviceInstance = await module.resolve(i18n_service_1.I18nService);
+            expect(serviceInstance.getLocale()).toBe("en");
+        });
+    });
+    describe("getDict", () => {
+        it("should return empty object when no dictionary loader registered", async () => {
+            const dict = await service.getDict();
+            expect(dict).toEqual({});
+        });
+        it("should call registered dictionary loader", async () => {
+            const mockDict = { hello: "Hello", goodbye: "Goodbye" };
+            const mockLoader = jest.fn().mockResolvedValue(mockDict);
+            service.registerDictionaryLoader(mockLoader);
+            const dict = await service.getDict();
+            expect(mockLoader).toHaveBeenCalledWith("en");
+            expect(dict).toEqual(mockDict);
+        });
+        it("should cache dictionary after first load", async () => {
+            const mockDict = { hello: "Hello" };
+            const mockLoader = jest.fn().mockResolvedValue(mockDict);
+            service.registerDictionaryLoader(mockLoader);
+            await service.getDict();
+            await service.getDict();
+            expect(mockLoader).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("translate", () => {
+        beforeEach(() => {
+            const mockDict = {
+                welcome: "Welcome",
+                greeting: "Hello {{name}}!",
+                nested: {
+                    key: "Nested value",
+                },
+            };
+            service.registerDictionaryLoader(jest.fn().mockResolvedValue(mockDict));
+        });
+        it("should translate simple key", async () => {
+            const result = await service.translate("welcome");
+            expect(result).toBe("Welcome");
+        });
+        it("should translate with variables", async () => {
+            const result = await service.translate("greeting", { name: "John" });
+            expect(result).toBe("Hello John!");
+        });
+        it("should translate nested key", async () => {
+            const result = await service.translate("nested.key");
+            expect(result).toBe("Nested value");
+        });
+        it("should return empty string for non-existent key", async () => {
+            const result = await service.translate("nonexistent");
+            expect(result).toBe("");
+        });
+    });
+});

package/dist/i18n/__tests__/t.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/i18n/__tests__/t.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const t_1 = require("../t");
+describe("Translation Function (t)", () => {
+    const mockDict = {
+        simple: "Hello",
+        nested: {
+            key: "Nested value",
+            deep: {
+                value: "Deep nested value",
+            },
+        },
+        withVar: "Hello {{name}}!",
+        withMultipleVars: "Hello {{name}}, you have {{count}} messages",
+    };
+    describe("Simple translations", () => {
+        it("should translate simple key", () => {
+            expect((0, t_1.t)(mockDict, "simple")).toBe("Hello");
+        });
+        it("should translate nested key", () => {
+            expect((0, t_1.t)(mockDict, "nested.key")).toBe("Nested value");
+        });
+        it("should translate deeply nested key", () => {
+            expect((0, t_1.t)(mockDict, "nested.deep.value")).toBe("Deep nested value");
+        });
+    });
+    describe("Variable interpolation", () => {
+        it("should interpolate single variable", () => {
+            expect((0, t_1.t)(mockDict, "withVar", { name: "John" })).toBe("Hello John!");
+        });
+        it("should interpolate multiple variables", () => {
+            expect((0, t_1.t)(mockDict, "withMultipleVars", { name: "John", count: 5 })).toBe("Hello John, you have 5 messages");
+        });
+        it("should handle missing variables gracefully", () => {
+            expect((0, t_1.t)(mockDict, "withVar", {})).toBe("Hello !");
+        });
+        it("should handle numeric variables", () => {
+            expect((0, t_1.t)(mockDict, "withMultipleVars", { name: "John", count: 0 })).toBe("Hello John, you have 0 messages");
+        });
+    });
+    describe("Edge cases", () => {
+        it("should return empty string for non-existent key", () => {
+            expect((0, t_1.t)(mockDict, "nonexistent")).toBe("");
+        });
+        it("should return empty string for non-string value", () => {
+            expect((0, t_1.t)(mockDict, "nested")).toBe("");
+        });
+        it("should handle empty dictionary", () => {
+            expect((0, t_1.t)({}, "any")).toBe("");
+        });
+    });
+    describe("tUnsafe function", () => {
+        it("should work with dynamic keys", () => {
+            expect((0, t_1.tUnsafe)(mockDict, "simple")).toBe("Hello");
+        });
+        it("should work with nested keys", () => {
+            expect((0, t_1.tUnsafe)(mockDict, "nested.key")).toBe("Nested value");
+        });
+        it("should interpolate variables", () => {
+            expect((0, t_1.tUnsafe)(mockDict, "withVar", { name: "Jane" })).toBe("Hello Jane!");
+        });
+        it("should handle non-existent keys", () => {
+            expect((0, t_1.tUnsafe)(mockDict, "invalid.key")).toBe("");
+        });
+    });
+});

package/dist/i18n/i18n-module.options.d.ts

@@ -0,0 +1,10 @@
+export type I18nUrlPattern = "query" | "header";
+export interface I18nModuleOptions {
+    defaultLocale: string;
+    locales: string[];
+    urlPattern?: I18nUrlPattern;
+    translationsPath?: string;
+    cookieName?: string;
+    queryParam?: string;
+}
+export declare const I18N_MODULE_OPTIONS = "I18N_MODULE_OPTIONS";

package/dist/i18n/i18n-module.options.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18N_MODULE_OPTIONS = void 0;
+exports.I18N_MODULE_OPTIONS = "I18N_MODULE_OPTIONS";

package/dist/i18n/i18n-switcher.controller.d.ts

@@ -0,0 +1,12 @@
+import { I18nHelper } from "./i18n.helper";
+export declare class I18nSwitcherController {
+    private readonly i18nHelper;
+    constructor(i18nHelper: I18nHelper);
+    switchLocale(locale: string, req: any, res: any): any;
+    getConfig(): {
+        locales: string[];
+        defaultLocale: string;
+        urlPattern: import("./i18n-module.options").I18nUrlPattern;
+        queryParam: string;
+    };
+}

package/dist/i18n/i18n-switcher.controller.js

@@ -0,0 +1,80 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nSwitcherController = void 0;
+const common_1 = require("@nestjs/common");
+const i18n_helper_1 = require("./i18n.helper");
+let I18nSwitcherController = class I18nSwitcherController {
+    i18nHelper;
+    constructor(i18nHelper) {
+        this.i18nHelper = i18nHelper;
+    }
+    switchLocale(locale, req, res) {
+        if (!locale) {
+            return res
+                .status(common_1.HttpStatus.BAD_REQUEST)
+                .send({ error: "Locale is required" });
+        }
+        const validatedLocale = this.i18nHelper.validateLocale(locale);
+        this.i18nHelper.setLocaleCookie(res, validatedLocale);
+        const referer = req.headers.referer || req.headers.origin || "/";
+        let currentPath = "/";
+        let query = {};
+        try {
+            const refererUrl = new URL(referer);
+            const requestOrigin = `${req.protocol}://${req.hostname}${req.hostname === "localhost" && req.port ? ":" + req.port : ""}`;
+            if (refererUrl.origin !== requestOrigin) {
+                currentPath = "/";
+            }
+            else {
+                currentPath = refererUrl.pathname;
+                refererUrl.searchParams.forEach((value, key) => {
+                    query[key] = value;
+                });
+            }
+        }
+        catch {
+            currentPath = "/";
+        }
+        const redirectUrl = this.i18nHelper.buildLocaleUrl(validatedLocale, currentPath, query);
+        return res.send({
+            success: true,
+            locale: validatedLocale,
+            redirectUrl,
+        });
+    }
+    getConfig() {
+        return this.i18nHelper.getClientConfig();
+    }
+};
+exports.I18nSwitcherController = I18nSwitcherController;
+__decorate([
+    (0, common_1.Post)("switch-locale"),
+    __param(0, (0, common_1.Body)("locale")),
+    __param(1, (0, common_1.Req)()),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", void 0)
+], I18nSwitcherController.prototype, "switchLocale", null);
+__decorate([
+    (0, common_1.Get)("config"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], I18nSwitcherController.prototype, "getConfig", null);
+exports.I18nSwitcherController = I18nSwitcherController = __decorate([
+    (0, common_1.Controller)("api/i18n"),
+    __metadata("design:paramtypes", [i18n_helper_1.I18nHelper])
+], I18nSwitcherController);

package/dist/i18n/i18n-types.d.ts

@@ -0,0 +1,8 @@
+export type NestedKeyOf<ObjectType extends object> = {
+    [Key in keyof ObjectType & string]: ObjectType[Key] extends object ? ObjectType[Key] extends Array<any> ? Key : `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key]>}` : Key;
+}[keyof ObjectType & string];
+export type DeepValue<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? Rest extends string ? DeepValue<T[First], Rest> : never : never : K extends keyof T ? T[K] : never;
+export type ExtractVariables<T extends string> = T extends `${string}{{${infer Var}}}${infer Rest}` ? {
+    [K in Var | keyof ExtractVariables<Rest>]: string | number;
+} : Record<string, never>;
+export type RequiresVariables<T> = T extends string ? T extends `${string}{{${string}}}${string}` ? true : false : false;

package/dist/i18n/i18n-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i18n/i18n.helper.d.ts

@@ -0,0 +1,14 @@
+import type { I18nModuleOptions } from "./i18n-module.options";
+export declare class I18nHelper {
+    private readonly options;
+    constructor(options: I18nModuleOptions);
+    buildLocaleUrl(locale: string, currentPath: string, query?: Record<string, string>): string;
+    setLocaleCookie(res: any, locale: string): void;
+    validateLocale(locale: string): string;
+    getClientConfig(): {
+        locales: string[];
+        defaultLocale: string;
+        urlPattern: import("./i18n-module.options").I18nUrlPattern;
+        queryParam: string;
+    };
+}

package/dist/i18n/i18n.helper.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nHelper = void 0;
+const common_1 = require("@nestjs/common");
+const i18n_module_options_1 = require("./i18n-module.options");
+let I18nHelper = class I18nHelper {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    buildLocaleUrl(locale, currentPath, query) {
+        const { urlPattern, queryParam = "lang" } = this.options;
+        switch (urlPattern) {
+            case "query": {
+                const params = new URLSearchParams(query || {});
+                params.set(queryParam, locale);
+                return `${currentPath}?${params.toString()}`;
+            }
+            case "header":
+            default: {
+                if (query && Object.keys(query).length > 0) {
+                    const params = new URLSearchParams(query);
+                    return `${currentPath}?${params.toString()}`;
+                }
+                return currentPath;
+            }
+        }
+    }
+    setLocaleCookie(res, locale) {
+        const { cookieName = "locale" } = this.options;
+        res.setCookie(cookieName, locale, {
+            path: "/",
+            maxAge: 365 * 24 * 60 * 60,
+            httpOnly: false,
+            sameSite: "lax",
+        });
+    }
+    validateLocale(locale) {
+        if (!this.options.locales?.includes(locale)) {
+            return this.options.defaultLocale || "en";
+        }
+        return locale;
+    }
+    getClientConfig() {
+        return {
+            locales: this.options.locales || ["en"],
+            defaultLocale: this.options.defaultLocale || "en",
+            urlPattern: this.options.urlPattern || "query",
+            queryParam: this.options.queryParam || "lang",
+        };
+    }
+};
+exports.I18nHelper = I18nHelper;
+exports.I18nHelper = I18nHelper = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(i18n_module_options_1.I18N_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], I18nHelper);

package/dist/i18n/i18n.interceptor.d.ts

@@ -0,0 +1,9 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
+import { Observable } from "rxjs";
+import type { I18nModuleOptions } from "./i18n-module.options";
+export declare class I18nInterceptor implements NestInterceptor {
+    private options;
+    constructor(options: I18nModuleOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private parseCookie;
+}

package/dist/i18n/i18n.interceptor.js

@@ -0,0 +1,99 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const i18n_module_options_1 = require("./i18n-module.options");
+let I18nInterceptor = class I18nInterceptor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const locales = this.options.locales;
+        const defaultLocale = this.options.defaultLocale;
+        let locale = undefined;
+        let shouldSetCookie = false;
+        switch (this.options.urlPattern) {
+            case "query":
+                const queryLang = request.query?.[this.options.queryParam || "lang"];
+                if (queryLang && locales.includes(queryLang)) {
+                    locale = queryLang;
+                    shouldSetCookie = true;
+                }
+                break;
+            case "header":
+                const xLang = request.headers["x-lang"];
+                if (xLang && locales.includes(xLang)) {
+                    locale = xLang;
+                    shouldSetCookie = true;
+                }
+                break;
+        }
+        const cookieLang = this.parseCookie(request.headers.cookie, this.options.cookieName || "locale");
+        if (!locale) {
+            if (cookieLang && locales.includes(cookieLang)) {
+                locale = cookieLang;
+            }
+        }
+        if (!locale) {
+            const acceptLanguage = request.headers["accept-language"];
+            if (acceptLanguage) {
+                const preferredLocale = acceptLanguage
+                    .split(",")[0]
+                    .split("-")[0]
+                    .toLowerCase();
+                if (locales.includes(preferredLocale)) {
+                    locale = preferredLocale;
+                }
+            }
+        }
+        if (!locale) {
+            locale = defaultLocale;
+        }
+        request.locale = locale;
+        if (shouldSetCookie && cookieLang !== locale) {
+            const cookieName = this.options.cookieName || "locale";
+            const maxAge = 365 * 24 * 60 * 60;
+            response.header("Set-Cookie", `${cookieName}=${locale}; Path=/; Max-Age=${maxAge}; HttpOnly; SameSite=Lax`);
+        }
+        return next.handle();
+    }
+    parseCookie(cookieHeader, name) {
+        if (!cookieHeader)
+            return undefined;
+        const cookies = cookieHeader.split(";").map((c) => c.trim());
+        const cookie = cookies.find((c) => c.startsWith(`${name}=`));
+        if (!cookie)
+            return undefined;
+        const eqIndex = cookie.indexOf("=");
+        if (eqIndex === -1)
+            return undefined;
+        const value = cookie.slice(eqIndex + 1);
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            return value;
+        }
+    }
+};
+exports.I18nInterceptor = I18nInterceptor;
+exports.I18nInterceptor = I18nInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(i18n_module_options_1.I18N_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], I18nInterceptor);

package/dist/i18n/i18n.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from "@nestjs/common";
+import { I18nModuleOptions } from "./i18n-module.options";
+export declare class I18nModule {
+    static forRoot(options: I18nModuleOptions): DynamicModule;
+}

package/dist/i18n/i18n.module.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var I18nModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const i18n_service_1 = require("./i18n.service");
+const i18n_interceptor_1 = require("./i18n.interceptor");
+const i18n_helper_1 = require("./i18n.helper");
+const i18n_switcher_controller_1 = require("./i18n-switcher.controller");
+const i18n_module_options_1 = require("./i18n-module.options");
+let I18nModule = I18nModule_1 = class I18nModule {
+    static forRoot(options) {
+        const moduleOptions = {
+            defaultLocale: options.defaultLocale || "en",
+            locales: options.locales || ["en"],
+            urlPattern: options.urlPattern || "query",
+            translationsPath: options.translationsPath || "./dictionaries",
+            cookieName: options.cookieName || "locale",
+            queryParam: options.queryParam || "lang",
+        };
+        return {
+            module: I18nModule_1,
+            controllers: [i18n_switcher_controller_1.I18nSwitcherController],
+            providers: [
+                {
+                    provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                    useValue: moduleOptions,
+                },
+                i18n_service_1.I18nService,
+                i18n_helper_1.I18nHelper,
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useClass: i18n_interceptor_1.I18nInterceptor,
+                },
+            ],
+            exports: [i18n_service_1.I18nService, i18n_helper_1.I18nHelper, i18n_module_options_1.I18N_MODULE_OPTIONS],
+        };
+    }
+};
+exports.I18nModule = I18nModule;
+exports.I18nModule = I18nModule = I18nModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], I18nModule);

package/dist/i18n/i18n.service.d.ts

@@ -0,0 +1,12 @@
+import type { I18nModuleOptions } from "./i18n-module.options";
+export declare class I18nService {
+    private request;
+    private options;
+    private dict;
+    private getDictionaryFn;
+    constructor(request: any, options: I18nModuleOptions);
+    registerDictionaryLoader(fn: (locale: string) => Promise<any>): void;
+    getDict(): Promise<Record<string, any>>;
+    getLocale(): string;
+    translate(key: string, vars?: Record<string, string | number>): Promise<string>;
+}

package/dist/i18n/i18n.service.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const i18n_module_options_1 = require("./i18n-module.options");
+let I18nService = class I18nService {
+    request;
+    options;
+    dict = null;
+    getDictionaryFn = null;
+    constructor(request, options) {
+        this.request = request;
+        this.options = options;
+    }
+    registerDictionaryLoader(fn) {
+        this.getDictionaryFn = fn;
+    }
+    async getDict() {
+        if (!this.dict) {
+            const locale = this.request.locale || this.options.defaultLocale;
+            if (this.getDictionaryFn) {
+                this.dict = await this.getDictionaryFn(locale);
+            }
+            else {
+                console.warn("No dictionary loader registered. Call registerDictionaryLoader() in your app.");
+                this.dict = {};
+            }
+        }
+        return this.dict ?? {};
+    }
+    getLocale() {
+        return this.request.locale || this.options.defaultLocale;
+    }
+    async translate(key, vars) {
+        const dict = await this.getDict();
+        const value = key.split(".").reduce((acc, k) => acc?.[k], dict);
+        if (typeof value !== "string")
+            return "";
+        return value.replace(/\{\{(.*?)\}\}/g, (_match, k) => String(vars?.[k.trim()] ?? ""));
+    }
+};
+exports.I18nService = I18nService;
+exports.I18nService = I18nService = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
+    __param(0, (0, common_1.Inject)(core_1.REQUEST)),
+    __param(1, (0, common_1.Inject)(i18n_module_options_1.I18N_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, Object])
+], I18nService);

package/dist/i18n/index.d.ts

@@ -0,0 +1,10 @@
+export { I18nModule } from "./i18n.module";
+export { I18nService } from "./i18n.service";
+export { I18nInterceptor } from "./i18n.interceptor";
+export { I18nHelper } from "./i18n.helper";
+export { I18nSwitcherController } from "./i18n-switcher.controller";
+export { CurrentLocale } from "./locale.decorator";
+export { t, tUnsafe } from "./t";
+export { I18N_MODULE_OPTIONS } from "./i18n-module.options";
+export type { I18nModuleOptions, I18nUrlPattern } from "./i18n-module.options";
+export type { NestedKeyOf, DeepValue, ExtractVariables, RequiresVariables, } from "./i18n-types";