NgRx

eventGroup defines events like [Notifications Page] opened; withReducer maps events to state changes; withEventHandlers reacts with side effects and returns new events, which are dispatched. Reducers see each event first, so handlers observe the updated state.

A typed input, signalStoreFeature({ methods: type<{ loadPage(i: number): void }>() }, ...), makes the host declare loadPage or fail to compile. withFeature((store) => withPaging((i) => store.fetchUsers(i))) passes the dependency explicitly and keeps the feature independent of host names.

SignalStore state is protected by default: the store's public type exposes a read-only state source, and patchState needs a writable one. Add a method such as setTrack() in withMethods; protectedState: false also works but drops the guarantee.

A shared loadBooks command hides which source fired it, so the DevTools log shows identical entries and handlers cannot treat sources differently. Dispatch one [Source] Event action per source instead, and let the loading reaction listen for all of them.

provideStoreDevtools defaults to maxAge: false, an unbounded action and state history, and logOnly: false, full time travel and dispatch from the extension. In production, cap maxAge and set logOnly from isDevMode(), or leave the DevTools out of the bundle.

Provide provideMockActions(() => actions$) and a fake payment API, subscribe to the effect and assert the actions it emits; feed a failing charge then a good one and expect a failure action, then a success action.

setResult changes what the selector returns but emits nothing; call store.refreshState() so subscribers re-evaluate. Overrides live on the shared selector objects, so call store.resetSelectors() in afterEach or they leak into later tests.

Neither replaces the other in NgRx 22. Use the global Store where many features react to shared events and you want an action log and Store DevTools; SignalStores for feature- or view-scoped state; signalState for small private state in one class.

getSelectors() returns selectIds, selectEntities, selectAll and selectTotal. With no argument they read an EntityState directly; given a selector for the feature slice, they become memoized selectors that start from the root state.

concatLatestFrom calls its factory only when a matching action arrives, passing that action, so the selector is not subscribed at startup and can depend on the action's data. It has lived in @ngrx/operators since NgRx 18.

The extraSelectors factory receives the selectors createFeature generated (the feature selector and one per property) and returns more, which are merged into the feature object. It suits selectors derived from that one slice; joins across features belong in a separate file.

withProps adds arbitrary members, such as observables, injected services or private helpers, that are not state. withLinkedState adds state slices derived from other signals that stay writable with patchState and recompute when their sources change.

Passing a function to Store.dispatch creates an Angular effect that dispatches the returned action initially and again whenever a signal read inside it changes. It returns an EffectRef, and ends with its injector: the caller's, a passed one, or the root.

Wrap the store in unprotected() from @ngrx/signals/testing and call patchState on it; use that only to arrange state no public method can reach, and prefer driving the store through its own methods.

Plain store methods stay the default; the Events plugin pays off when several stores react to one occurrence or must not know each other. Conventions: one update style per slice, pure reducers, I/O in handlers, scoped dispatchers.