@angular-architects/ngrx-toolkit 19.0.1 → 19.1.0

package/lib/immutable-state/with-immutable-state.d.ts

@@ -0,0 +1,60 @@
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
+/**
+ * The implementation of this feature is a little bit tricky.
+ *
+ * `signalStore` does a shallow clone in the initial phase, in order to
+ * merge all different states together.
+ *
+ * Shallow cloning also happens in `patchState`.
+ *
+ * With shallow cloning, the root state object is replaced, which means,
+ * the freezing only stays for its nested properties but not for
+ * the primitive and immediate properties.
+ *
+ * For example:
+ *
+ * ```ts
+ * const state = {
+ *   id: 1,
+ *   address: {
+ *     street: 'Main St',
+ *     city: 'Springfield',
+ *   }
+ * }
+ * ```
+ *
+ * Running `Object.freeze` on `state` will freeze the `address` object, and
+ * the `id`. But since `state` is shallow cloned, the "frozing" state of the
+ * `id` is lost. `address`, being an object, is still frozen.
+ *
+ * To overcome that, we run `watchState` and run `deepFreeze`
+ * on every change.
+ */
+/**
+ * Prevents mutation of the state.
+ *
+ * This is done by deeply applying `Object.freeze`. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * @param state the state object
+ * @param options enable protection in production (default: false)
+ */
+export declare function withImmutableState<State extends object>(state: State, options?: {
+    enableInProduction?: boolean;
+}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;
+/**
+ * Prevents mutation of the state.
+ *
+ * This is done by deeply applying `Object.freeze`. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * @param stateFactory a function returning the state object
+ * @param options enable protection in production (default: false)
+ */
+export declare function withImmutableState<State extends object>(stateFactory: () => State, options?: {
+    enableInProduction?: boolean;
+}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;

package/lib/with-conditional.d.ts

@@ -0,0 +1,50 @@
+import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
+/**
+ * `withConditional` activates a feature based on a given condition.
+ *
+ * **Use Cases**
+ * - Conditionally activate features based on the **store state** or other criteria.
+ * - Choose between **two different implementations** of a feature.
+ *
+ * **Type Constraints**
+ * Both features must have **exactly the same state, props, and methods**.
+ * Otherwise, a type error will occur.
+ *
+ *
+ * **Usage**
+ *
+ * ```typescript
+ * const withUser = signalStoreFeature(
+ *   withState({ id: 1, name: 'Konrad' }),
+ *   withHooks(store => ({
+ *     onInit() {
+ *       // user loading logic
+ *     }
+ *   }))
+ * );
+ *
+ * function withFakeUser() {
+ *   return signalStoreFeature(
+ *     withState({ id: 0, name: 'anonymous' })
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withMethods(() => ({
+ *     useRealUser: () => true
+ *   })),
+ *   withConditional((store) => store.useRealUser(), withUser, withFakeUser)
+ * )
+ * ```
+ *
+ * @param condition - A function that determines which feature to activate based on the store state.
+ * @param featureIfTrue - The feature to activate if the condition evaluates to `true`.
+ * @param featureIfFalse - The feature to activate if the condition evaluates to `false`.
+ * @returns A `SignalStoreFeature` that applies the selected feature based on the condition.
+ */
+export declare function withConditional<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(condition: (store: StateSignals<Input['state']> & Input['props'] & Input['methods']) => boolean, featureIfTrue: SignalStoreFeature<NoInfer<Input>, Output>, featureIfFalse: SignalStoreFeature<NoInfer<Input>, NoInfer<Output>>): SignalStoreFeature<Input, Output>;
+export declare const emptyFeature: SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {};
+    props: {};
+    methods: {};
+}>;

package/lib/with-feature-factory.d.ts

@@ -0,0 +1,26 @@
+import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
+type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<Input['state']> & Input['props'] & Input['methods'];
+/**
+ * Allows to pass properties, methods, or signals from a SignalStore
+ * to a feature.
+ *
+ * Typically, a `signalStoreFeature` can have input constraints on
+ *
+ * ```typescript
+ * function withSum(a: Signal<number>, b: Signal<number>) {
+ *   return signalStoreFeature(
+ *     withComputed(() => ({
+ *       sum: computed(() => a() + b())
+ *     }))
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withState({ a: 1, b: 2 }),
+ *   withFeatureFactory((store) => withSum(store.a, store.b))
+ * );
+ * ```
+ * @param factoryFn
+ */
+export declare function withFeatureFactory<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(factoryFn: (store: StoreForFactory<Input>) => SignalStoreFeature<Input, Output>): SignalStoreFeature<Input, Output>;
+export {};

package/lib/with-pagination.d.ts

@@ -7,7 +7,7 @@
  */
 import { Signal } from '@angular/core';
 import { SignalStoreFeature, EmptyFeatureResult } from '@ngrx/signals';
-import { EntityComputed, EntityState, NamedEntityComputed } from './shared/signal-store-models';
+import { MethodsDictionary } from '@ngrx/signals/src/signal-store-models';
 export type Page = {
     label: string | number;
     value: number;
@@ -46,19 +46,6 @@ export type NamedPaginationServiceSignals<E, Collection extends string> = {
 } & {
     [K in Collection as `hasPrevious${Capitalize<K>}Page`]: Signal<boolean>;
 };
-export type NamedPaginationServiceMethods<Collection extends string> = {
-    [K in Collection as `set${Capitalize<K>}PageSize`]: (size: number) => void;
-} & {
-    [K in Collection as `next${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `previous${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `last${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `first${Capitalize<K>}Page`]: () => void;
-} & {
-    [K in Collection as `goto${Capitalize<K>}Page`]: (page: number) => void;
-};
 export type PaginationServiceState<E> = {
     selectedPageEntities: Array<E>;
     currentPage: number;
@@ -79,32 +66,19 @@ export type PaginationServiceSignals<E> = {
     hasNextPage: Signal<boolean>;
     hasPreviousPage: Signal<boolean>;
 };
-export type PaginationServiceMethods = {
-    setPageSize: (size: number) => void;
-    nextPageKey: () => void;
-    previousPage: () => void;
-    lastPage: () => void;
-    firstPage: () => void;
-    gotoPage: (page: number) => void;
-};
 export type SetPaginationState<E, Collection extends string | undefined> = Collection extends string ? NamedPaginationServiceState<E, Collection> : PaginationServiceState<E>;
 export declare function withPagination<E, Collection extends string>(options: {
     entity: E;
     collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    props: NamedEntityComputed<E, Collection>;
-}, {
+}): SignalStoreFeature<EmptyFeatureResult, {
     state: NamedPaginationServiceState<E, Collection>;
     props: NamedPaginationServiceSignals<E, Collection>;
-    methods: NamedPaginationServiceMethods<Collection>;
+    methods: MethodsDictionary;
 }>;
-export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult & {
-    state: EntityState<E>;
-    props: EntityComputed<E>;
-}, {
+export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, {
     state: PaginationServiceState<E>;
     props: PaginationServiceSignals<E>;
-    methods: PaginationServiceMethods;
+    methods: MethodsDictionary;
 }>;
 export declare function gotoPage<E, Collection extends string>(page: number, options?: {
     collection: Collection;

package/lib/with-redux.d.ts

@@ -33,10 +33,98 @@ type ReducerFunction<ReducerAction, State> = (state: State, action: ActionFnPayl
 type ReducerFactory<StateActionFns extends ActionFns, State> = (actions: StateActionFns, on: <ReducerAction extends {
     type: string;
 }>(action: ReducerAction, reducerFn: ReducerFunction<ReducerAction, State>) => void) => void;
+/**
+ * Creates a reducer function to separate the reducer logic into another file.
+ *
+ * ```typescript
+ * interface FlightState {
+ *   flights: Flight[];
+ *   effect1: boolean;
+ *   effect2: boolean;
+ * }
+ *
+ * const initialState: FlightState = {
+ *   flights: [],
+ *   effect1: false,
+ *   effect2: false,
+ * };
+ *
+ * const actions = {
+ *   init: noPayload,
+ *   updateEffect1: payload<{ value: boolean }>(),
+ *   updateEffect2: payload<{ value: boolean }>(),
+ * };
+ *
+ * const reducer = createReducer<FlightState, typeof actions>((actions, on) => {
+ *   on(actions.updateEffect1, (state, { value }) => {
+ *     patchState(state, { effect1: value });
+ *   });
+ *
+ *   on(actions.updateEffect2, (state, { value }) => {
+ *     patchState(state, { effect2: value });
+ *   });
+ * });
+ *
+ * signalStore(
+ *   withState(initialState),
+ *   withRedux({
+ *     actions,
+ *     reducer,
+ *   })
+ * );
+ * ```
+ * @param reducerFactory
+ */
+export declare function createReducer<State extends object, Actions extends ActionsFnSpecs>(reducerFactory: ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>): ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>;
 /** Effect **/
 type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns, create: <EffectAction extends {
     type: string;
 }>(action: EffectAction) => Observable<ActionFnPayload<EffectAction>>) => Record<string, Observable<unknown>>;
+/**
+ * Creates the effects function to separate the effects logic into another file.
+ *
+ * ```typescript
+ * interface FlightState {
+ *   flights: Flight[];
+ *   effect1: boolean;
+ *   effect2: boolean;
+ * }
+ *
+ * const initialState: FlightState = {
+ *   flights: [],
+ *   effect1: false,
+ *   effect2: false,
+ * };
+ *
+ * const actions = {
+ *   init: noPayload,
+ *   updateEffect1: payload<{ value: boolean }>(),
+ *   updateEffect2: payload<{ value: boolean }>(),
+ * };
+ *
+ * const effects = createEffects(actions, (actions, create) => {
+ *   return {
+ *     init1$: create(actions.init).pipe(
+ *       map(() => actions.updateEffect1({ value: true }))
+ *     ),
+ *     init2$: create(actions.init).pipe(
+ *       map(() => actions.updateEffect2({ value: true }))
+ *     ),
+ *   };
+ * });
+ *
+ * signalStore(
+ *   withState(initialState),
+ *   withRedux({
+ *     actions,
+ *     effects,
+ *   })
+ * );
+ * ```
+ * @param actions
+ * @param effectsFactory
+ */
+export declare function createEffects<Actions extends ActionsFnSpecs>(actions: Actions, effectsFactory: EffectsFactory<ActionFnsCreator<Actions>>): EffectsFactory<ActionFnsCreator<Actions>>;
 /**
  * @param redux redux
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-architects/ngrx-toolkit",
-  "version": "19.0.1",
+  "version": "19.1.0",
   "license": "MIT",
   "repository": {
     "type": "GitHub",