@hazeljs/i18n 0.2.0-beta.57

package/dist/i18n.service.js

@@ -0,0 +1,228 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nFormatter = exports.I18nService = void 0;
+const core_1 = require("@hazeljs/core");
+/**
+ * The central translation and formatting service.
+ *
+ * Inject this service into any controller or provider to translate keys,
+ * apply interpolation and pluralization, and format numbers / dates / currency
+ * using the native Intl API — with zero external dependencies.
+ */
+let I18nService = class I18nService {
+    constructor() {
+        this.store = new Map();
+        this.format = new I18nFormatter(this);
+    }
+    /**
+     * Called by I18nModule after translations have been loaded from disk.
+     */
+    initialize(store, options) {
+        this.store = store;
+        this.options = options;
+    }
+    /**
+     * Translate a dot-notation key for the given locale.
+     *
+     * @param key     Dot-separated translation key, e.g. "errors.notFound".
+     * @param opts    Optional count (plural), vars (interpolation) and locale override.
+     * @returns       The translated string, or the key itself if not found.
+     *
+     * @example
+     * i18n.t('welcome', { vars: { name: 'Alice' } })
+     * // → "Welcome, Alice!" (from en.json: { "welcome": "Welcome, {name}!" })
+     *
+     * i18n.t('items', { count: 3, vars: { count: '3' } })
+     * // → "3 items" (from en.json: { "items": { "one": "1 item", "other": "{count} items" } })
+     */
+    t(key, opts = {}) {
+        const locale = opts.locale ?? this.getCurrentLocale();
+        const raw = this.resolve(key, locale);
+        if (raw === null)
+            return key;
+        const selected = this.selectPluralForm(raw, opts.count);
+        return this.interpolate(selected, opts.vars);
+    }
+    /**
+     * Returns the current request-scoped locale, falling back to the default.
+     * When used with the LocaleMiddleware the locale is stored on the current
+     * async context; outside a request context the default locale is used.
+     */
+    getCurrentLocale() {
+        return this.options?.defaultLocale ?? 'en';
+    }
+    /**
+     * Returns all translation keys available for a given locale (flattened to
+     * dot-notation paths), useful for debugging and tooling.
+     */
+    getKeys(locale) {
+        const targetLocale = locale ?? this.getCurrentLocale();
+        const map = this.store.get(targetLocale);
+        if (!map)
+            return [];
+        return this.flattenKeys(map);
+    }
+    /**
+     * Returns all loaded locale codes.
+     */
+    getLocales() {
+        return Array.from(this.store.keys());
+    }
+    /**
+     * Checks whether a key exists for the given locale.
+     */
+    has(key, locale) {
+        return this.resolve(key, locale ?? this.getCurrentLocale()) !== null;
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Traverses the translation map using a dot-notation key.
+     * Falls back to the fallbackLocale when the key is missing.
+     */
+    resolve(key, locale) {
+        const value = this.resolveInMap(key, this.store.get(locale));
+        if (value !== null)
+            return value;
+        // Try the fallback locale
+        const fallback = this.options?.fallbackLocale;
+        if (fallback && fallback !== locale) {
+            return this.resolveInMap(key, this.store.get(fallback));
+        }
+        return null;
+    }
+    resolveInMap(key, map) {
+        if (!map)
+            return null;
+        const parts = key.split('.');
+        let node = map;
+        for (const part of parts) {
+            if (node === null || node === undefined || typeof node !== 'object' || Array.isArray(node)) {
+                return null;
+            }
+            const record = node;
+            node = record[part];
+        }
+        return node !== undefined ? node : null;
+    }
+    /**
+     * Given a translation value that may be a plain string or a plural object,
+     * returns the appropriate form.
+     *
+     * Uses the native Intl.PluralRules API, defaulting to "other" when
+     * the value is not a plural object.
+     */
+    selectPluralForm(value, count) {
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'object' && ('one' in value || 'other' in value)) {
+            const pluralObj = value;
+            if (count === undefined) {
+                return pluralObj['other'] ?? pluralObj['one'] ?? String(value);
+            }
+            const locale = this.getCurrentLocale();
+            let rule;
+            try {
+                rule = new Intl.PluralRules(locale).select(count);
+            }
+            catch {
+                rule = 'other';
+            }
+            return pluralObj[rule] ?? pluralObj['other'] ?? pluralObj['one'] ?? String(value);
+        }
+        // Nested object used as a namespace — return stringified (edge case)
+        return JSON.stringify(value);
+    }
+    /**
+     * Replaces {placeholder} tokens in a string with values from vars.
+     */
+    interpolate(template, vars) {
+        if (!vars)
+            return template;
+        return template.replace(/\{(\w+)\}/g, (_, key) => {
+            const val = vars[key];
+            return val !== undefined ? String(val) : `{${key}}`;
+        });
+    }
+    flattenKeys(map, prefix = '') {
+        const keys = [];
+        for (const [k, v] of Object.entries(map)) {
+            const fullKey = prefix ? `${prefix}.${k}` : k;
+            if (typeof v === 'object' && v !== null && !('one' in v) && !('other' in v)) {
+                keys.push(...this.flattenKeys(v, fullKey));
+            }
+            else {
+                keys.push(fullKey);
+            }
+        }
+        return keys;
+    }
+};
+exports.I18nService = I18nService;
+exports.I18nService = I18nService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [])
+], I18nService);
+/**
+ * Exposes Intl-backed formatters, accessible as `i18nService.format.*`.
+ */
+class I18nFormatter {
+    constructor(service) {
+        this.service = service;
+    }
+    /**
+     * Format a number using Intl.NumberFormat.
+     *
+     * @example
+     * i18n.format.number(1234567.89, 'de', { maximumFractionDigits: 2 })
+     * // → "1.234.567,89"
+     */
+    number(value, locale, opts) {
+        const loc = locale ?? this.service.getCurrentLocale();
+        return new Intl.NumberFormat(loc, opts).format(value);
+    }
+    /**
+     * Format a date using Intl.DateTimeFormat.
+     *
+     * @example
+     * i18n.format.date(new Date(), 'fr', { dateStyle: 'long' })
+     * // → "4 mars 2026"
+     */
+    date(value, locale, opts) {
+        const loc = locale ?? this.service.getCurrentLocale();
+        return new Intl.DateTimeFormat(loc, opts).format(value);
+    }
+    /**
+     * Format a monetary value using Intl.NumberFormat with style 'currency'.
+     *
+     * @example
+     * i18n.format.currency(49.99, 'en', 'USD')
+     * // → "$49.99"
+     */
+    currency(value, locale, currency = 'USD') {
+        const loc = locale ?? this.service.getCurrentLocale();
+        return new Intl.NumberFormat(loc, { style: 'currency', currency }).format(value);
+    }
+    /**
+     * Format a relative time using Intl.RelativeTimeFormat.
+     *
+     * @example
+     * i18n.format.relative(-3, 'day', 'en')
+     * // → "3 days ago"
+     */
+    relative(value, unit, locale, opts) {
+        const loc = locale ?? this.service.getCurrentLocale();
+        return new Intl.RelativeTimeFormat(loc, opts).format(value, unit);
+    }
+}
+exports.I18nFormatter = I18nFormatter;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=i18n.service.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.service.test.d.ts","sourceRoot":"","sources":["../src/i18n.service.test.ts"],"names":[],"mappings":""}

package/dist/i18n.service.test.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    Service: () => () => undefined,
+}));
+const i18n_service_1 = require("./i18n.service");
+const DEFAULT_OPTIONS = {
+    defaultLocale: 'en',
+    fallbackLocale: 'en',
+    translationsPath: './translations',
+    detection: ['query', 'cookie', 'header'],
+    queryParam: 'lang',
+    cookieName: 'locale',
+    isGlobal: true,
+};
+function makeStore(entries) {
+    const store = new Map();
+    for (const [locale, map] of Object.entries(entries)) {
+        store.set(locale, map);
+    }
+    return store;
+}
+describe('I18nService', () => {
+    let service;
+    beforeEach(() => {
+        service = new i18n_service_1.I18nService();
+    });
+    describe('getCurrentLocale()', () => {
+        it('returns "en" when not initialized', () => {
+            expect(service.getCurrentLocale()).toBe('en');
+        });
+        it('returns the configured defaultLocale', () => {
+            service.initialize(new Map(), { ...DEFAULT_OPTIONS, defaultLocale: 'fr' });
+            expect(service.getCurrentLocale()).toBe('fr');
+        });
+    });
+    describe('getLocales()', () => {
+        it('returns empty array when no translations loaded', () => {
+            service.initialize(new Map(), DEFAULT_OPTIONS);
+            expect(service.getLocales()).toEqual([]);
+        });
+        it('returns all locale codes from the store', () => {
+            const store = makeStore({ en: {}, fr: {}, de: {} });
+            service.initialize(store, DEFAULT_OPTIONS);
+            expect(service.getLocales()).toEqual(expect.arrayContaining(['en', 'fr', 'de']));
+        });
+    });
+    describe('getKeys()', () => {
+        it('returns empty array for unknown locale', () => {
+            service.initialize(new Map(), DEFAULT_OPTIONS);
+            expect(service.getKeys('xx')).toEqual([]);
+        });
+        it('returns flat keys for simple map', () => {
+            const store = makeStore({ en: { hello: 'Hello', bye: 'Goodbye' } });
+            service.initialize(store, DEFAULT_OPTIONS);
+            expect(service.getKeys('en')).toEqual(expect.arrayContaining(['hello', 'bye']));
+        });
+        it('returns dot-notation keys for nested map', () => {
+            const store = makeStore({ en: { errors: { notFound: 'Not found', invalid: 'Invalid' } } });
+            service.initialize(store, DEFAULT_OPTIONS);
+            expect(service.getKeys('en')).toEqual(expect.arrayContaining(['errors.notFound', 'errors.invalid']));
+        });
+        it('does not flatten plural objects (one/other keys)', () => {
+            const store = makeStore({ en: { items: { one: '1 item', other: '{count} items' } } });
+            service.initialize(store, DEFAULT_OPTIONS);
+            expect(service.getKeys('en')).toContain('items');
+        });
+        it('uses getCurrentLocale() when no locale arg given', () => {
+            const store = makeStore({ en: { hi: 'Hi' } });
+            service.initialize(store, { ...DEFAULT_OPTIONS, defaultLocale: 'en' });
+            expect(service.getKeys()).toContain('hi');
+        });
+    });
+    describe('has()', () => {
+        beforeEach(() => {
+            const store = makeStore({ en: { greeting: 'Hello', errors: { notFound: 'Not found' } } });
+            service.initialize(store, DEFAULT_OPTIONS);
+        });
+        it('returns true for existing key', () => {
+            expect(service.has('greeting')).toBe(true);
+        });
+        it('returns true for nested key', () => {
+            expect(service.has('errors.notFound')).toBe(true);
+        });
+        it('returns false for missing key', () => {
+            expect(service.has('nonexistent')).toBe(false);
+        });
+        it('returns false for a locale with no translations when fallback is the same', () => {
+            // fallbackLocale matches the requested locale → no cross-locale fallback
+            const svc = new i18n_service_1.I18nService();
+            const s = makeStore({ en: { greeting: 'Hello' } });
+            svc.initialize(s, { ...DEFAULT_OPTIONS, defaultLocale: 'fr', fallbackLocale: 'fr' });
+            expect(svc.has('greeting', 'fr')).toBe(false);
+        });
+    });
+    describe('t()', () => {
+        describe('basic translation', () => {
+            beforeEach(() => {
+                const store = makeStore({
+                    en: {
+                        welcome: 'Welcome!',
+                        nested: { key: 'Nested value' },
+                    },
+                    fr: {
+                        welcome: 'Bienvenue !',
+                    },
+                });
+                service.initialize(store, DEFAULT_OPTIONS);
+            });
+            it('returns translated string', () => {
+                expect(service.t('welcome')).toBe('Welcome!');
+            });
+            it('returns the key when not found', () => {
+                expect(service.t('missing.key')).toBe('missing.key');
+            });
+            it('translates a nested key', () => {
+                expect(service.t('nested.key')).toBe('Nested value');
+            });
+            it('uses locale override from opts', () => {
+                expect(service.t('welcome', { locale: 'fr' })).toBe('Bienvenue !');
+            });
+        });
+        describe('interpolation', () => {
+            beforeEach(() => {
+                const store = makeStore({
+                    en: {
+                        greeting: 'Hello, {name}!',
+                        multi: '{a} and {b}',
+                        missing_var: 'Hello, {unknown}!',
+                    },
+                });
+                service.initialize(store, DEFAULT_OPTIONS);
+            });
+            it('replaces placeholders with vars', () => {
+                expect(service.t('greeting', { vars: { name: 'Alice' } })).toBe('Hello, Alice!');
+            });
+            it('replaces multiple placeholders', () => {
+                expect(service.t('multi', { vars: { a: 'foo', b: 'bar' } })).toBe('foo and bar');
+            });
+            it('leaves unmatched placeholders as-is', () => {
+                expect(service.t('missing_var', { vars: {} })).toBe('Hello, {unknown}!');
+            });
+            it('accepts numeric var values', () => {
+                expect(service.t('greeting', { vars: { name: 42 } })).toBe('Hello, 42!');
+            });
+        });
+        describe('pluralization', () => {
+            beforeEach(() => {
+                const store = makeStore({
+                    en: {
+                        items: { one: '1 item', other: '{count} items' },
+                        cats: { one: 'one cat', other: 'many cats' },
+                    },
+                });
+                service.initialize(store, { ...DEFAULT_OPTIONS, defaultLocale: 'en' });
+            });
+            it('selects "one" form for count=1', () => {
+                expect(service.t('items', { count: 1, vars: { count: '1' } })).toBe('1 item');
+            });
+            it('selects "other" form for count > 1', () => {
+                expect(service.t('items', { count: 3, vars: { count: '3' } })).toBe('3 items');
+            });
+            it('selects "other" form when count is undefined', () => {
+                expect(service.t('cats')).toBe('many cats');
+            });
+            it('falls back to "one" if "other" missing and count undefined', () => {
+                const store = makeStore({ en: { only_one: { one: 'just one' } } });
+                service.initialize(store, DEFAULT_OPTIONS);
+                expect(service.t('only_one')).toBe('just one');
+            });
+        });
+        describe('fallback locale', () => {
+            it('falls back to fallbackLocale when key is missing in requested locale', () => {
+                const store = makeStore({
+                    en: { only_en: 'English only' },
+                    fr: {},
+                });
+                service.initialize(store, {
+                    ...DEFAULT_OPTIONS,
+                    defaultLocale: 'fr',
+                    fallbackLocale: 'en',
+                });
+                expect(service.t('only_en')).toBe('English only');
+            });
+            it('returns key when neither locale nor fallback has the key', () => {
+                const store = makeStore({ en: {}, fr: {} });
+                service.initialize(store, {
+                    ...DEFAULT_OPTIONS,
+                    defaultLocale: 'fr',
+                    fallbackLocale: 'en',
+                });
+                expect(service.t('missing')).toBe('missing');
+            });
+            it('does not recurse when fallback equals locale', () => {
+                const store = makeStore({ en: {} });
+                service.initialize(store, {
+                    ...DEFAULT_OPTIONS,
+                    defaultLocale: 'en',
+                    fallbackLocale: 'en',
+                });
+                expect(service.t('missing')).toBe('missing');
+            });
+        });
+        describe('edge cases', () => {
+            it('returns JSON.stringify for a nested object value (namespace path)', () => {
+                const store = makeStore({ en: { ns: { sub: 'value' } } });
+                service.initialize(store, DEFAULT_OPTIONS);
+                // Requesting 'ns' returns the object itself, which gets JSON.stringified
+                const result = service.t('ns');
+                expect(result).toBe(JSON.stringify({ sub: 'value' }));
+            });
+            it('returns key when traversal hits a null node', () => {
+                const store = makeStore({ en: { parent: 'string_not_object' } });
+                service.initialize(store, DEFAULT_OPTIONS);
+                expect(service.t('parent.child')).toBe('parent.child');
+            });
+            it('handles invalid Intl locale gracefully (falls back to "other")', () => {
+                const store = makeStore({ xx: { items: { one: '1 item', other: 'many items' } } });
+                service.initialize(store, { ...DEFAULT_OPTIONS, defaultLocale: 'xx' });
+                expect(service.t('items', { count: 1 })).toBeTruthy();
+            });
+        });
+    });
+});
+describe('I18nFormatter', () => {
+    let service;
+    let formatter;
+    beforeEach(() => {
+        service = new i18n_service_1.I18nService();
+        service.initialize(new Map(), { ...DEFAULT_OPTIONS, defaultLocale: 'en' });
+        formatter = service.format;
+    });
+    describe('number()', () => {
+        it('formats a number using default locale', () => {
+            const result = formatter.number(1234);
+            expect(result).toMatch(/1[,.]?234/);
+        });
+        it('accepts an explicit locale', () => {
+            const result = formatter.number(1234.5, 'de');
+            expect(typeof result).toBe('string');
+        });
+        it('accepts Intl.NumberFormatOptions', () => {
+            const result = formatter.number(1234.567, 'en', { maximumFractionDigits: 2 });
+            expect(result).toMatch(/1,234\.57/);
+        });
+    });
+    describe('date()', () => {
+        it('formats a Date object', () => {
+            const d = new Date('2026-03-04T00:00:00Z');
+            const result = formatter.date(d, 'en');
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('formats a timestamp number', () => {
+            const ts = new Date('2026-01-01').getTime();
+            const result = formatter.date(ts, 'en');
+            expect(typeof result).toBe('string');
+        });
+        it('uses default locale when none provided', () => {
+            const result = formatter.date(new Date());
+            expect(typeof result).toBe('string');
+        });
+    });
+    describe('currency()', () => {
+        it('formats USD by default', () => {
+            const result = formatter.currency(49.99, 'en');
+            expect(result).toContain('49.99');
+        });
+        it('formats EUR with explicit currency code', () => {
+            const result = formatter.currency(10, 'de', 'EUR');
+            expect(typeof result).toBe('string');
+        });
+        it('uses default locale when none provided', () => {
+            const result = formatter.currency(100);
+            expect(typeof result).toBe('string');
+        });
+    });
+    describe('relative()', () => {
+        it('formats a relative time', () => {
+            const result = formatter.relative(-3, 'day', 'en');
+            expect(result).toMatch(/3 days? ago/);
+        });
+        it('formats future time', () => {
+            const result = formatter.relative(2, 'hour', 'en');
+            expect(result).toMatch(/2 hours?/);
+        });
+        it('uses default locale when none provided', () => {
+            const result = formatter.relative(1, 'month');
+            expect(typeof result).toBe('string');
+        });
+        it('accepts Intl.RelativeTimeFormatOptions', () => {
+            const result = formatter.relative(-1, 'day', 'en', { numeric: 'auto' });
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @hazeljs/i18n — Internationalization module for HazelJS
+ *
+ * Quick start:
+ *
+ * ```ts
+ * import { I18nModule, I18nService, Lang } from '@hazeljs/i18n';
+ *
+ * \@HazelModule({
+ *   imports: [
+ *     I18nModule.forRoot({
+ *       defaultLocale: 'en',
+ *       translationsPath: './translations',
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export { I18nModule } from './i18n.module';
+export { I18nService, I18nFormatter } from './i18n.service';
+export { LocaleMiddleware, getLocaleFromRequest, LOCALE_KEY } from './i18n.middleware';
+export { I18nInterceptor } from './i18n.interceptor';
+export { TranslationLoader } from './translation.loader';
+export { Lang, extractLang } from './decorators/lang.decorator';
+export type { I18nOptions, ResolvedI18nOptions, TranslateOptions, TranslationMap, TranslationValue, LocaleStore, LocaleDetectionStrategy, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAChE,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,uBAAuB,GACxB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * @hazeljs/i18n — Internationalization module for HazelJS
+ *
+ * Quick start:
+ *
+ * ```ts
+ * import { I18nModule, I18nService, Lang } from '@hazeljs/i18n';
+ *
+ * \@HazelModule({
+ *   imports: [
+ *     I18nModule.forRoot({
+ *       defaultLocale: 'en',
+ *       translationsPath: './translations',
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLang = exports.Lang = exports.TranslationLoader = exports.I18nInterceptor = exports.LOCALE_KEY = exports.getLocaleFromRequest = exports.LocaleMiddleware = exports.I18nFormatter = exports.I18nService = exports.I18nModule = void 0;
+var i18n_module_1 = require("./i18n.module");
+Object.defineProperty(exports, "I18nModule", { enumerable: true, get: function () { return i18n_module_1.I18nModule; } });
+var i18n_service_1 = require("./i18n.service");
+Object.defineProperty(exports, "I18nService", { enumerable: true, get: function () { return i18n_service_1.I18nService; } });
+Object.defineProperty(exports, "I18nFormatter", { enumerable: true, get: function () { return i18n_service_1.I18nFormatter; } });
+var i18n_middleware_1 = require("./i18n.middleware");
+Object.defineProperty(exports, "LocaleMiddleware", { enumerable: true, get: function () { return i18n_middleware_1.LocaleMiddleware; } });
+Object.defineProperty(exports, "getLocaleFromRequest", { enumerable: true, get: function () { return i18n_middleware_1.getLocaleFromRequest; } });
+Object.defineProperty(exports, "LOCALE_KEY", { enumerable: true, get: function () { return i18n_middleware_1.LOCALE_KEY; } });
+var i18n_interceptor_1 = require("./i18n.interceptor");
+Object.defineProperty(exports, "I18nInterceptor", { enumerable: true, get: function () { return i18n_interceptor_1.I18nInterceptor; } });
+var translation_loader_1 = require("./translation.loader");
+Object.defineProperty(exports, "TranslationLoader", { enumerable: true, get: function () { return translation_loader_1.TranslationLoader; } });
+var lang_decorator_1 = require("./decorators/lang.decorator");
+Object.defineProperty(exports, "Lang", { enumerable: true, get: function () { return lang_decorator_1.Lang; } });
+Object.defineProperty(exports, "extractLang", { enumerable: true, get: function () { return lang_decorator_1.extractLang; } });

package/dist/translation.loader.d.ts

@@ -0,0 +1,16 @@
+import { LocaleStore } from './types';
+/**
+ * Loads JSON translation files from a directory and returns a locale store.
+ *
+ * Each file must be named <locale>.json (e.g. en.json, fr.json, zh-TW.json).
+ * Nested objects in the JSON are kept as-is; key lookup via dot-notation is
+ * resolved at translation time inside I18nService.
+ */
+export declare class TranslationLoader {
+    /**
+     * Read all *.json files from the given directory.
+     * Returns a Map keyed by locale code (the filename without extension).
+     */
+    static load(translationsPath: string): Promise<LocaleStore>;
+}
+//# sourceMappingURL=translation.loader.d.ts.map

package/dist/translation.loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation.loader.d.ts","sourceRoot":"","sources":["../src/translation.loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B;;;OAGG;WACU,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;CAmClE"}

package/dist/translation.loader.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslationLoader = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Loads JSON translation files from a directory and returns a locale store.
+ *
+ * Each file must be named <locale>.json (e.g. en.json, fr.json, zh-TW.json).
+ * Nested objects in the JSON are kept as-is; key lookup via dot-notation is
+ * resolved at translation time inside I18nService.
+ */
+class TranslationLoader {
+    /**
+     * Read all *.json files from the given directory.
+     * Returns a Map keyed by locale code (the filename without extension).
+     */
+    static async load(translationsPath) {
+        const store = new Map();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(translationsPath);
+        }
+        catch {
+            // Directory does not exist — return an empty store so the service starts
+            // gracefully without translations (it will return keys as-is).
+            return store;
+        }
+        const jsonFiles = entries.filter((file) => (0, path_1.extname)(file) === '.json');
+        await Promise.all(jsonFiles.map(async (file) => {
+            const locale = (0, path_1.basename)(file, '.json');
+            const filePath = (0, path_1.join)(translationsPath, file);
+            try {
+                const raw = await (0, promises_1.readFile)(filePath, 'utf-8');
+                const translations = JSON.parse(raw);
+                store.set(locale, translations);
+            }
+            catch (err) {
+                // Skip malformed files rather than crashing the application.
+                const message = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`[@hazeljs/i18n] Failed to load translation file "${filePath}": ${message}\n`);
+            }
+        }));
+        return store;
+    }
+}
+exports.TranslationLoader = TranslationLoader;

package/dist/translation.loader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=translation.loader.test.d.ts.map