refactor: make currentLang honestly nullable (Language | null) instead of undefined cast

_currentLang signal now uses null as initial value instead of
undefined-cast-to-Language. getCurrentLang() and currentLang signal
return Language | null. Internal callers get null guards where needed.

Author: CodeAndWeb

projects/ngx-translate/src/lib/translate.service.interface.ts

@@ -121,7 +121,7 @@ export abstract class ITranslateService {
      * The current language as a reactive Signal.
      * Use `getCurrentLang()` for a non-reactive snapshot.
      */
-    public abstract readonly currentLang: Signal<Language>;
+    public abstract readonly currentLang: Signal<Language | null>;
 
     /**
      * The fallback language as a reactive Signal.
@@ -133,7 +133,7 @@ export abstract class ITranslateService {
      * Returns the current language as a plain value (non-reactive).
      * Use `currentLang` signal for reactive usage.
      */
-    public abstract getCurrentLang(): Language;
+    public abstract getCurrentLang(): Language | null;
 
     /**
      * Returns the loaded translations for the given language.

projects/ngx-translate/src/lib/translate.service.ts

@@ -79,7 +79,7 @@ export class TranslateService implements ITranslateService {
 
     protected _onLangChange = new Subject<LangChangeEvent>();
     protected _onFallbackLangChange = new Subject<FallbackLangChangeEvent>();
-    protected _currentLang: WritableSignal<Language> = signal(undefined as unknown as Language);
+    protected _currentLang: WritableSignal<Language | null> = signal(null);
     protected _fallbackLang: WritableSignal<Language | null> = signal(null);
     private _onTranslationRefresh: Observable<void> | null = null;
 
@@ -311,8 +311,8 @@ export class TranslateService implements ITranslateService {
         this._onLangChange.next({ lang: lang, translations: this.store.getTranslations(lang) });
     }
 
-    public getCurrentLang(): Language {
-        return this.isRoot ? this._currentLang() : (this.parent?.getCurrentLang() ?? (undefined as unknown as Language));
+    public getCurrentLang(): Language | null {
+        return this.isRoot ? this._currentLang() : (this.parent?.getCurrentLang() ?? null);
     }
 
     protected loadAndCompileTranslations(
@@ -407,7 +407,10 @@ export class TranslateService implements ITranslateService {
         const fallbackLang = this.getFallbackLang();
 
         // 1. Try own store (currentLang)
-        let res = this.store.getTranslationValue(currentLang, key);
+        let res: InterpolatableTranslation | undefined;
+        if (currentLang) {
+            res = this.store.getTranslationValue(currentLang, key);
+        }
 
         // 2. Try own store (fallbackLang) - null values also trigger fallback
         if (!isDefinedAndNotNull(res) && fallbackLang && fallbackLang !== currentLang) {
@@ -650,7 +653,7 @@ export class TranslateService implements ITranslateService {
     public set(
         key: string,
         translation: string | TranslationObject,
-        lang: Language = this.getCurrentLang(),
+        lang: Language = this.getCurrentLang()!,
     ): void {
         this.store.setTranslations(
             lang,
@@ -721,7 +724,7 @@ export class TranslateService implements ITranslateService {
      * The current language as a reactive Signal.
      * Use `getCurrentLang()` for a non-reactive snapshot.
      */
-    get currentLang(): Signal<Language> {
+    get currentLang(): Signal<Language | null> {
         return this.isRoot ? this._currentLang.asReadonly() : this.parent!.currentLang;
     }
 

projects/ngx-translate/src/tests/translate.service.spec.ts

@@ -85,7 +85,7 @@ describe("TranslateService (Delayed loading)", () => {
     it("currentLang should be the language, on which use() was called last - reverse order", fakeAsync(() => {
         const completionOrder: string[] = [];
 
-        expect(translate.getCurrentLang()).toBeUndefined();
+        expect(translate.getCurrentLang()).toBeNull();
 
         translate.use("delay-20").subscribe(() => completionOrder.push("delay-20"));
         expect(translate.getCurrentLang()).toEqual("delay-20");
@@ -1145,11 +1145,14 @@ describe("TranslateService (Error Conditions and Recovery)", () => {
             });
         });
 
-        it("should handle array with invalid elements", () => {
-            expect(() => {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                translate.get([null, undefined, ""] as any);
-            }).toThrow();
+        it("should handle array with invalid elements gracefully", (done) => {
+            // With honest nullable currentLang, invalid keys no longer crash —
+            // they fall through to the missing translation handler which returns the key
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            translate.get([null, undefined, ""] as any).subscribe((res: Translation) => {
+                expect(res).toEqual({ null: null, undefined: undefined, "": "" });
+                done();
+            });
         });
 
         it("should handle deeply nested invalid parameters", () => {
@@ -1816,3 +1819,35 @@ describe("error logging", () => {
         );
     });
 });
+
+describe("TranslateService pre-initialization (no use() called)", () => {
+    let translate: TranslateService;
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                provideTranslateService({ loader: provideTranslateLoader(FakeLoader) }),
+            ],
+        });
+        translate = TestBed.inject(TranslateService);
+    });
+
+    it("getCurrentLang() should return null before use() is called", () => {
+        expect(translate.getCurrentLang()).toBeNull();
+    });
+
+    it("currentLang signal should be null before use() is called", () => {
+        expect(translate.currentLang()).toBeNull();
+    });
+
+    it("instant() should return the key before use() is called", () => {
+        expect(translate.instant("TEST")).toEqual("TEST");
+    });
+
+    it("get() should return the key before use() is called", (done) => {
+        translate.get("TEST").subscribe((result) => {
+            expect(result).toEqual("TEST");
+            done();
+        });
+    });
+});