feat(signals): add withLinkedState

Generates and adds the properties of a `linkedSignal`
to the store's state.

## Usage Notes:

```typescript
const UserStore = signalStore(
  withState({ options: [1, 2, 3] }),
  withLinkedState(({ options }) => ({ selectOption: options()[0] ?? undefined }))
);
```

The resulting state is of type `{ options: number[], selectOption: number | undefined }`.
Whenever the `options` signal changes, the `selectOption` will automatically update.

For advanced use cases, `linkedSignal` can be called within `withLinkedState`:

```typescript
const UserStore = signalStore(
  withState({ id: 1 }),
  withLinkedState(({ id }) => linkedSignal({
    source: id,
    computation: () => ({ firstname: '', lastname: '' })
  }))
)
```

Author: rainerhahnekamp

modules/signals/spec/state-source.spec.ts

@@ -293,6 +293,27 @@ describe('StateSource', () => {
         TestBed.flushEffects();
         expect(executionCount).toBe(2);
       });
+
+      it('does not support a dynamic type as state', () => {
+        const Store = signalStore(
+          { providedIn: 'root' },
+          withState<Record<number, number>>({}),
+          withMethods((store) => ({
+            addNumber(num: number): void {
+              patchState(store, {
+                [num]: num,
+              });
+            },
+          }))
+        );
+        const store = TestBed.inject(Store);
+
+        store.addNumber(1);
+        store.addNumber(2);
+        store.addNumber(3);
+
+        expect(getState(store)).toEqual({});
+      });
     });
   });
 

modules/signals/spec/types/with-linked-state.types.spec.ts

@@ -0,0 +1,101 @@
+import { expecter } from 'ts-snippet';
+import { compilerOptions } from './helpers';
+
+describe('patchState', () => {
+  const expectSnippet = expecter(
+    (code) => `
+        import { computed, inject, linkedSignal, Signal, signal } from '@angular/core';
+        import {
+          patchState,
+          signalStore,
+          withState,
+          withLinkedState,
+          withMethods
+        } from '@ngrx/signals';
+
+        ${code}
+      `,
+    compilerOptions()
+  );
+
+  it('does not have access to methods', () => {
+    const snippet = `
+      signalStore(
+        withMethods(() => ({
+          foo: () => 'bar',
+        })),
+        withLinkedState(({ foo }) => ({ value: foo() }))
+      );
+      `;
+
+    expectSnippet(snippet).toFail(/Property 'foo' does not exist on type '{}'/);
+  });
+
+  it('does not have access to STATE_SOURCE', () => {
+    const snippet = `
+      signalStore(
+        withState({ foo: 'bar' }),
+        withLinkedState((store) => {
+          patchState(store, { foo: 'baz' });
+          return { bar: 'foo' };
+        })
+      )
+      `;
+
+    expectSnippet(snippet).toFail(
+      /is not assignable to parameter of type 'WritableStateSource<object>'./
+    );
+  });
+
+  it('cannot return a primitive value', () => {
+    const snippet = `
+      signalStore(
+        withLinkedState(() => 'foo')
+      )
+      `;
+
+    expectSnippet(snippet).toFail(
+      /Type 'string' is not assignable to type 'object | WritableSignal<object>'./
+    );
+  });
+
+  it('resolves to a normal state signal with automatic linkedSignal', () => {
+    const snippet = `
+      const UserStore = signalStore(
+        { providedIn: 'root' },
+        withLinkedState(() => ({ firstname: 'John', lastname: 'Doe' }))
+      );
+
+      const userStore = new UserStore();
+
+      const firstname = userStore.firstname;
+      const lastname = userStore.lastname;
+    `;
+
+    expectSnippet(snippet).toSucceed();
+
+    expectSnippet(snippet).toInfer('firstname', 'Signal<string>');
+    expectSnippet(snippet).toInfer('lastname', 'Signal<string>');
+  });
+
+  it('resolves to a normal state signal with manual linkedSignal', () => {
+    const snippet = `
+      const UserStore = signalStore(
+        { providedIn: 'root' },
+        withLinkedState(() =>
+          linkedSignal(() => ({ firstname: 'John', lastname: 'Doe' }))
+        )
+      );
+
+      const userStore = new UserStore();
+
+      const firstname = userStore.firstname;
+      const lastname = userStore.lastname;
+    `;
+
+    expectSnippet(snippet).toSucceed();
+
+    expectSnippet(snippet).toInfer('firstname', 'Signal<string>');
+    expectSnippet(snippet).toInfer('lastname', 'Signal<string>');
+  });
+});