docs(signals): apply new naming convention from Angular styleguide

projects/ngrx.io/content/guide/signals/rxjs-integration.md

@@ -15,7 +15,7 @@ import { map, pipe, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent {
+export class Numbers {
   // 👇 This reactive method will have an input argument
   // of type `number | Signal<number> | Observable<number>`.
   readonly logDoubledNumber = rxMethod<number>(
@@ -32,20 +32,20 @@ Each invocation of the reactive method pushes the input value through the reacti
 When called with a static value, the reactive chain executes once.
 
 ```ts
-import { Component, OnInit } from '@angular/core';
+import { Component } from '@angular/core';
 import { map, pipe, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers {
   readonly logDoubledNumber = rxMethod<number>(
     pipe(
       map((num) => num * 2),
       tap(console.log)
     )
   );
 
-  ngOnInit(): void {
+  constructor() {
     this.logDoubledNumber(1);
     // console output: 2
 
@@ -58,20 +58,20 @@ export class NumbersComponent implements OnInit {
 When a reactive method is called with a signal, the reactive chain is executed every time the signal value changes.
 
 ```ts
-import { Component, OnInit, signal } from '@angular/core';
+import { Component, signal } from '@angular/core';
 import { map, pipe, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers {
   readonly logDoubledNumber = rxMethod<number>(
     pipe(
       map((num) => num * 2),
       tap(console.log)
     )
   );
 
-  ngOnInit(): void {
+  constructor() {
     const num = signal(10);
     this.logDoubledNumber(num);
     // console output: 20
@@ -85,20 +85,20 @@ export class NumbersComponent implements OnInit {
 When a reactive method is called with an observable, the reactive chain is executed every time the observable emits a new value.
 
 ```ts
-import { Component, OnInit } from '@angular/core';
+import { Component } from '@angular/core';
 import { interval, map, of, pipe, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers {
   readonly logDoubledNumber = rxMethod<number>(
     pipe(
       map((num) => num * 2),
       tap(console.log)
     )
   );
 
-  ngOnInit(): void {
+  constructor() {
     const num1$ = of(100, 200, 300);
     this.logDoubledNumber(num1$);
     // console output: 200, 400, 600
@@ -119,15 +119,15 @@ The `rxMethod` is a great choice for handling API calls in a reactive manner.
 The subsequent example demonstrates how to use `rxMethod` to fetch the book by id whenever the `selectedBookId` signal value changes.
 
 ```ts
-import { Component, inject, OnInit, signal } from '@angular/core';
+import { Component, inject, signal } from '@angular/core';
 import { concatMap, filter, pipe } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 import { tapResponse } from '@ngrx/operators';
-import { Book } from './book.model';
-import { BooksService } from './books.service';
+import { BooksService } from './books-service';
+import { Book } from './book';
 
 @Component({ /* ... */ })
-export class BooksComponent implements OnInit {
+export class BookList {
   readonly #booksService = inject(BooksService);
 
   readonly bookMap = signal<Record<string, Book>>({});
@@ -147,7 +147,7 @@ export class BooksComponent implements OnInit {
     )
   );
 
-  ngOnInit(): void {
+  constructor() {
     // 👇 Load book by id whenever the `selectedBookId` value changes.
     this.loadBookById(this.selectedBookId);
   }
@@ -173,15 +173,15 @@ Further details can be found in the [Reactive Store Methods](guide/signals/signa
 To create a reactive method without arguments, the `void` type should be specified as a generic argument to the `rxMethod` function.
 
 ```ts
-import { Component, inject, OnInit, signal } from '@angular/core';
+import { Component, inject, signal } from '@angular/core';
 import { exhaustMap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 import { tapResponse } from '@ngrx/operators';
-import { Book } from './book.model';
-import { BooksService } from './books.service';
+import { BooksService } from './books-service';
+import { Book } from './book';
 
 @Component({ /* ... */ })
-export class BooksComponent implements OnInit {
+export class BookList {
   readonly #booksService = inject(BooksService);
   readonly books = signal<Book[]>([]);
 
@@ -197,7 +197,7 @@ export class BooksComponent implements OnInit {
     })
   );
 
-  ngOnInit(): void {
+  constructor() {
     this.loadAllBooks();
   }
 }
@@ -221,7 +221,7 @@ export class NumbersService {
 }
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly #injector = inject(Injector);
   readonly #numbersService = inject(NumbersService);
 
@@ -250,15 +250,15 @@ If the injector is not provided when calling the reactive method with a signal o
 If a reactive method needs to be cleaned up before the injector is destroyed, manual cleanup can be performed by calling the `destroy` method.
 
 ```ts
-import { Component, OnInit } from '@angular/core';
+import { Component } from '@angular/core';
 import { interval, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers {
   readonly logNumber = rxMethod<number>(tap(console.log));
 
-  ngOnInit(): void {
+  constructor() {
     const num1$ = interval(500);
     const num2$ = interval(1_000);
 
@@ -277,15 +277,15 @@ When invoked, the reactive method returns the object with the `destroy` method.
 This allows manual cleanup of a specific call, preserving the activity of other reactive method calls until the corresponding injector is destroyed.
 
 ```ts
-import { Component, OnInit } from '@angular/core';
+import { Component } from '@angular/core';
 import { interval, tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers {
   readonly logNumber = rxMethod<number>(tap(console.log));
 
-  ngOnInit(): void {
+  constructor() {
     const num1$ = interval(500);
     const num2$ = interval(1_000);
 
@@ -310,7 +310,7 @@ import { tap } from 'rxjs';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly #injector = inject(Injector);
 
   ngOnInit(): void {
@@ -322,4 +322,4 @@ export class NumbersComponent implements OnInit {
     logNumber(10);
   }
 }
-```
+```

projects/ngrx.io/content/guide/signals/signal-method.md

@@ -7,7 +7,7 @@ import { Component } from '@angular/core';
 import { signalMethod } from '@ngrx/signals';
 
 @Component({ /* ... */ })
-export class NumbersComponent {
+export class Numbers {
   // 👇 This method will have an input argument
   // of type `number | Signal<number>`.
   readonly logDoubledNumber = signalMethod<number>((num) => {
@@ -21,7 +21,7 @@ export class NumbersComponent {
 
 ```ts
 @Component({ /* ... */ })
-export class NumbersComponent {
+export class Numbers {
   readonly logDoubledNumber = signalMethod<number>((num) => {
     const double = num * 2;
     console.log(double);
@@ -44,27 +44,27 @@ export class NumbersComponent {
 ## Automatic Cleanup
 
 `signalMethod` uses an `effect` internally to track the Signal changes.
-By default, the `effect` runs in the injection context of the caller. In the example above, that is `NumbersComponent`. That means, that the `effect` is automatically cleaned up when the component is destroyed.
+By default, the `effect` runs in the injection context of the caller. In the example above, that is the `Numbers` component. That means, that the `effect` is automatically cleaned up when the component is destroyed.
 
 If the call happens outside an injection context, then the injector of the `signalMethod` is used. This would be the case, if `logDoubledNumber` runs in `ngOnInit`:
 
 ```ts
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly logDoubledNumber = signalMethod<number>((num) => {
     const double = num * 2;
     console.log(double);
   });
 
   ngOnInit(): void {
     const value = signal(2);
-    // 👇 Uses the injection context of the `NumbersComponent`.
+    // 👇 Uses the injection context of the `Numbers` component.
     this.logDoubledNumber(value);
   }
 }
 ```
 
-Even though `logDoubledNumber` is called outside an injection context, automatic cleanup occurs when `NumbersComponent` is destroyed, since `logDoubledNumber` was created within the component's injection context.
+Even though `logDoubledNumber` is called outside an injection context, automatic cleanup occurs when the `Numbers` component is destroyed, since `logDoubledNumber` was created within the component's injection context.
 
 However, when creating a `signalMethod` in an ancestor injection context, the cleanup behavior is different:
 
@@ -78,7 +78,7 @@ export class NumbersService {
 }
 
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly numbersService = inject(NumbersService);
 
   ngOnInit(): void {
@@ -89,7 +89,7 @@ export class NumbersComponent implements OnInit {
 }
 ```
 
-Here, the `effect` outlives the component, which would produce a memory leak.
+Here, the `effect` used internally by `signalMethod` outlives the component, which would produce a memory leak.
 
 <div class="alert is-important">
 
@@ -103,13 +103,13 @@ When a `signalMethod` is created in an ancestor injection context, it's necessar
 
 ```ts
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly numbersService = inject(NumbersService);
   readonly injector = inject(Injector);
 
   ngOnInit(): void {
     const value = signal(1);
-    // 👇 Providing the `NumbersComponent` injector
+    // 👇 Providing the `Numbers` component injector
     // to ensure cleanup on component destroy.
     this.numbersService.logDoubledNumber(value, {
       injector: this.injector,
@@ -127,10 +127,10 @@ The `signalMethod` must be initialized within an injection context. To initializ
 
 ```ts
 @Component({ /* ... */ })
-export class NumbersComponent implements OnInit {
+export class Numbers implements OnInit {
   readonly injector = inject(Injector);
 
-  ngOnInit() {
+  ngOnInit(): void {
     const logDoubledNumber = signalMethod<number>(
       (num) => console.log(num * 2),
       { injector: this.injector },
@@ -145,7 +145,7 @@ At first sight, `signalMethod`, might be the same as `effect`:
 
 ```ts
 @Component({ /* ... */ })
-export class NumbersComponent {
+export class Numbers {
   readonly num = signal(2);
   readonly logDoubledNumberEffect = effect(() => {
     console.log(this.num() * 2);