feat(core): make getRoot() public, add getParent + getRoot to ITranslateService

- getRoot() flipped from protected to public with TSDoc explaining
  isolated-subtree termination (parent === null at the boundary).
- ITranslateService gains abstract getParent() and getRoot() — the
  interface now represents the full public API of the concrete class
  (getParent was previously public-on-class-but-missing-from-interface).
- chain-walk-regression.spec adds two cases: getRoot() walks the chain
  to the root, and stops at an isolated subtree boundary.
- README mock recipe removed — it belongs on the docs site, not in the
  README. Webpage docs cover isLoading + getParent/getRoot semantics.

Author: CodeAndWeb

README.md

@@ -17,25 +17,6 @@ interfaces and explains how to develop custom plugins.
 In addition to that, a getting started tutorial is available here:
 [How to Translate Your Angular App with NGX-Translate](https://www.codeandweb.com/babeledit/tutorials/how-to-translate-your-angular-app-with-ngx-translate)
 
-## Testing components that use TranslateService
-
-When mocking `TranslateService` by structurally implementing `ITranslateService`,
-all abstract members must be provided. As of v18, that includes `isLoading`:
-
-```ts
-import { signal } from "@angular/core";
-import { ITranslateService } from "@ngx-translate/core";
-
-class MockTranslateService implements Partial<ITranslateService> {
-    // ...your existing mocked methods...
-    readonly isLoading = signal(false).asReadonly();
-}
-```
-
-Apps that subclass `TranslateService` directly are unaffected — the concrete
-`isLoading` implementation lives on the class. Only mocks that implement the
-interface structurally need this addition.
-
 ## Support for older versions
 
 We only support the current version with new updates and fixes.

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

@@ -172,4 +172,22 @@ export abstract class ITranslateService {
      * Returns the loaded translations for the given language.
      */
     public abstract getTranslations(language: Language): InterpolatableTranslationObject;
+
+    /**
+     * Returns the service this one inherits translations from, or `null` if
+     * this is a root (a top-level service or an isolated subtree root).
+     *
+     * A `null` return means the service is the terminus of its translation
+     * fallback chain — equivalent to "is this a root?".
+     */
+    public abstract getParent(): ITranslateService | null;
+
+    /**
+     * Returns the root of this service's hierarchy — the topmost service in
+     * the `getParent()` chain. For an isolated subtree, returns the subtree's
+     * root (since `getParent()` returns `null` at the isolation boundary).
+     *
+     * A root service returns itself.
+     */
+    public abstract getRoot(): ITranslateService;
 }

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

@@ -114,7 +114,15 @@ export class TranslateService implements ITranslateService {
         () => this.loadingTranslations.hasAny() || (this.parent?.isLoading() ?? false),
     );
 
-    protected getRoot(): TranslateService {
+    /**
+     * Returns the root of this service's hierarchy — the topmost service in
+     * the `getParent()` chain. For an isolated subtree, returns the subtree's
+     * root (since `parent === null` at the isolation boundary).
+     *
+     * A root service returns itself. Equivalent to walking `getParent()` until
+     * it returns `null`, but provided as a convenience.
+     */
+    public getRoot(): TranslateService {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let svc: TranslateService = this;
         while (svc.parent) svc = svc.parent;

projects/ngx-translate/src/tests/chain-walk-regression.spec.ts

@@ -86,4 +86,38 @@ describe("Chain walk regression (root + non-isolated child + grandchild)", () =>
         expect(childService.getParent()).toBe(rootService);
         expect(rootService.getParent()).toBeNull();
     });
+
+    it("getRoot() returns the topmost service in the chain", () => {
+        const { rootService, childService, grandchildService } = setup();
+        expect(rootService.getRoot()).toBe(rootService);
+        expect(childService.getRoot()).toBe(rootService);
+        expect(grandchildService.getRoot()).toBe(rootService);
+    });
+
+    it("getRoot() stops at an isolated subtree boundary", () => {
+        const rootInjector = Injector.create({
+            providers: [
+                provideTranslateService({
+                    loader: { provide: TranslateLoader, useValue: new FakeLoader({}) },
+                }),
+            ],
+        });
+        const rootService = rootInjector.get(TranslateService);
+
+        // Nested provideTranslateService() creates an isolated subtree — its
+        // root's getParent() returns null, so getRoot() returns itself.
+        const isolatedInjector = Injector.create({
+            providers: [
+                provideTranslateService({
+                    loader: { provide: TranslateLoader, useValue: new FakeLoader({}) },
+                }),
+            ],
+            parent: rootInjector,
+        });
+        const isolatedService = isolatedInjector.get(TranslateService);
+
+        expect(isolatedService.getParent()).toBeNull();
+        expect(isolatedService.getRoot()).toBe(isolatedService);
+        expect(rootService.getRoot()).toBe(rootService);
+    });
 });