@angular-architects/ngrx-toolkit 20.0.2 → 20.1.0

package/src/lib/with-redux.ts

@@ -1,387 +0,0 @@
-import {
-  EmptyFeatureResult,
-  SignalStoreFeature,
-  SignalStoreFeatureResult,
-  WritableStateSource,
-} from '@ngrx/signals';
-import { Observable, Subject } from 'rxjs';
-import { assertActionFnSpecs } from './assertions/assertions';
-
-/** Actions **/
-
-type Payload = Record<string, unknown>;
-
-type ActionFn<
-  Type extends string = string,
-  ActionPayload extends Payload = Payload,
-> = ((payload: ActionPayload) => ActionPayload & { type: Type }) & {
-  type: Type;
-};
-
-type ActionFns = Record<string, ActionFn>;
-
-export type ActionsFnSpecs = Record<string, Payload>;
-
-type ActionFnCreator<Spec extends ActionsFnSpecs> = {
-  [ActionName in keyof Spec]: (Record<never, never> extends Spec[ActionName]
-    ? () => Spec[ActionName] & { type: ActionName }
-    : (
-        payload: Spec[ActionName],
-      ) => Spec[ActionName] & { type: ActionName }) & {
-    type: ActionName & string;
-  };
-};
-
-type ActionFnPayload<Action> = Action extends (payload: infer Payload) => void
-  ? Payload
-  : never;
-
-type ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {
-  private: Record<string, Payload>;
-  public: Record<string, Payload>;
-}
-  ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']>
-  : ActionFnCreator<Spec>;
-
-type PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {
-  public: Record<string, Payload>;
-}
-  ? ActionFnCreator<Spec['public']>
-  : ActionFnCreator<Spec>;
-
-export function payload<Type extends Payload>(): Type {
-  return {} as Type;
-}
-
-export const noPayload = {};
-
-/** Reducer **/
-
-type ReducerFunction<ReducerAction, State> = (
-  state: State,
-  action: ActionFnPayload<ReducerAction>,
-) => void;
-
-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 function createReducer<
-  State extends object,
-  Actions extends ActionsFnSpecs,
->(
-  reducerFactory: ReducerFactory<
-    ActionFnsCreator<Actions>,
-    WritableStateSource<State>
-  >,
-) {
-  return reducerFactory;
-}
-
-/** Effect **/
-
-type EffectsFactory<StateActionFns extends ActionFns> = (
-  actions: StateActionFns,
-  create: <EffectAction extends { type: string }>(
-    action: EffectAction,
-  ) => Observable<ActionFnPayload<EffectAction>>,
-) => Record<string, Observable<unknown>>;
-
-/**
- * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
- *
- * 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 function createEffects<Actions extends ActionsFnSpecs>(
-  actions: Actions,
-  effectsFactory: EffectsFactory<ActionFnsCreator<Actions>>,
-) {
-  return effectsFactory;
-}
-
-// internal types
-
-/**
- * Record which holds all effects for a specific action type.
- * The values are Subject which the effect are subscribed to.
- * `createActionFns` will call next on these subjects.
- */
-type EffectsRegistry = Record<string, Subject<ActionFnPayload<unknown>>[]>;
-
-function createActionFns<Spec extends ActionsFnSpecs>(
-  actionFnSpecs: Spec,
-  reducerRegistry: Record<
-    string,
-    (state: unknown, payload: ActionFnPayload<unknown>) => void
-  >,
-  effectsRegistry: EffectsRegistry,
-  state: unknown,
-) {
-  const actionFns: Record<string, ActionFn> = {};
-
-  for (const type in actionFnSpecs) {
-    const actionFn = (payload: Payload) => {
-      const fullPayload = { ...payload, type };
-      const reducer = reducerRegistry[type];
-      if (reducer) {
-        (reducer as (state: unknown, payload: unknown) => void)(
-          state,
-          fullPayload as unknown,
-        );
-      }
-      const effectSubjects = effectsRegistry[type];
-      if (effectSubjects?.length) {
-        for (const effectSubject of effectSubjects) {
-          (effectSubject as unknown as Subject<unknown>).next(fullPayload);
-        }
-      }
-      return fullPayload;
-    };
-    actionFn.type = type.toString();
-    actionFns[type] = actionFn;
-  }
-
-  return actionFns;
-}
-
-function createPublicAndAllActionsFns<Spec extends ActionsFnSpecs>(
-  actionFnSpecs: Spec,
-  reducerRegistry: Record<
-    string,
-    (state: unknown, payload: ActionFnPayload<unknown>) => void
-  >,
-  effectsRegistry: EffectsRegistry,
-  state: unknown,
-): { all: ActionFns; publics: ActionFns } {
-  if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {
-    const privates = actionFnSpecs['private'] || {};
-    const publics = actionFnSpecs['public'] || {};
-
-    assertActionFnSpecs(privates);
-    assertActionFnSpecs(publics);
-
-    const privateActionFns = createActionFns(
-      privates,
-      reducerRegistry,
-      effectsRegistry,
-      state,
-    );
-    const publicActionFns = createActionFns(
-      publics,
-      reducerRegistry,
-      effectsRegistry,
-      state,
-    );
-
-    return {
-      all: { ...privateActionFns, ...publicActionFns },
-      publics: publicActionFns,
-    };
-  }
-
-  const actionFns = createActionFns(
-    actionFnSpecs,
-    reducerRegistry,
-    effectsRegistry,
-    state,
-  );
-
-  return { all: actionFns, publics: actionFns };
-}
-
-function fillReducerRegistry(
-  reducer: ReducerFactory<ActionFns, unknown>,
-  actionFns: ActionFns,
-  reducerRegistry: Record<
-    string,
-    (state: unknown, payload: ActionFnPayload<unknown>) => void
-  >,
-) {
-  function on(
-    action: { type: string },
-    reducerFn: (state: unknown, payload: ActionFnPayload<unknown>) => void,
-  ) {
-    reducerRegistry[action.type] = reducerFn;
-  }
-
-  reducer(actionFns, on);
-
-  return reducerRegistry;
-}
-
-function fillEffects(
-  effects: EffectsFactory<ActionFns>,
-  actionFns: ActionFns,
-  effectsRegistry: EffectsRegistry = {},
-): Observable<unknown>[] {
-  function create(action: { type: string }) {
-    const subject = new Subject<ActionFnPayload<unknown>>();
-    if (!(action.type in effectsRegistry)) {
-      effectsRegistry[action.type] = [];
-    }
-    effectsRegistry[action.type].push(subject);
-    return subject.asObservable();
-  }
-
-  const effectObservables = effects(actionFns, create);
-  return Object.values(effectObservables);
-}
-
-function startSubscriptions(observables: Observable<unknown>[]) {
-  return observables.map((observable) => observable.subscribe());
-}
-
-function processRedux<Spec extends ActionsFnSpecs, ReturnType>(
-  actionFnSpecs: Spec,
-  reducer: ReducerFactory<ActionFns, unknown>,
-  effects: EffectsFactory<ActionFns>,
-  store: unknown,
-) {
-  const reducerRegistry: Record<
-    string,
-    (state: unknown, payload: ActionFnPayload<unknown>) => void
-  > = {};
-  const effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>[]> =
-    {};
-  const actionsMap = createPublicAndAllActionsFns(
-    actionFnSpecs,
-    reducerRegistry,
-    effectsRegistry,
-    store,
-  );
-  const actionFns = actionsMap.all;
-  const publicActionsFns = actionsMap.publics;
-
-  fillReducerRegistry(reducer, actionFns, reducerRegistry);
-  const effectObservables = fillEffects(effects, actionFns, effectsRegistry);
-  const subscriptions = startSubscriptions(effectObservables);
-
-  return {
-    methods: publicActionsFns as ReturnType,
-    subscriptions: subscriptions,
-  };
-}
-
-/**
- * @param redux redux
- *
- * properties do not start with `with` since they are not extension functions on their own.
- *
- * no dependency to NgRx
- *
- * actions are passed to reducer and effects, but it is also possible to use other actions.
- * effects provide forAction and do not return anything. that is important because effects should stay inaccessible
- */
-export function withRedux<
-  Spec extends ActionsFnSpecs,
-  Input extends SignalStoreFeatureResult,
-  StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>,
-  PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>,
->(redux: {
-  actions: Spec;
-  reducer: ReducerFactory<StateActionFns, WritableStateSource<Input['state']>>;
-  effects: EffectsFactory<StateActionFns>;
-}): SignalStoreFeature<
-  Input,
-  EmptyFeatureResult & { methods: PublicStoreActionFns }
-> {
-  return (store) => {
-    const { methods } = processRedux<Spec, PublicStoreActionFns>(
-      redux.actions,
-      redux.reducer as ReducerFactory<ActionFns, unknown>,
-      redux.effects as EffectsFactory<ActionFns>,
-      store,
-    );
-    return {
-      ...store,
-      methods: { ...store.methods, ...methods },
-    };
-  };
-}

package/src/lib/with-reset.spec.ts

@@ -1,112 +0,0 @@
-import { effect } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import {
-  getState,
-  patchState,
-  signalStore,
-  withMethods,
-  withState,
-} from '@ngrx/signals';
-import { setResetState, withReset } from './with-reset';
-
-describe('withReset', () => {
-  const setup = () => {
-    const initialState = {
-      user: { id: 1, name: 'Konrad' },
-      address: { city: 'Vienna', zip: '1010' },
-    };
-
-    const Store = signalStore(
-      withState(initialState),
-      withReset(),
-      withMethods((store) => ({
-        changeUser(id: number, name: string) {
-          patchState(store, { user: { id, name } });
-        },
-        changeUserName(name: string) {
-          patchState(store, (value) => ({ user: { ...value.user, name } }));
-        },
-        changeAddress(city: string, zip: string) {
-          patchState(store, { address: { city, zip } });
-        },
-      })),
-    );
-
-    const store = TestBed.configureTestingModule({
-      providers: [Store],
-    }).inject(Store);
-
-    return { store, initialState };
-  };
-
-  it('should reset state to initial state', () => {
-    const { store, initialState } = setup();
-
-    store.changeUser(2, 'Max');
-    expect(getState(store)).toMatchObject({
-      user: { id: 2, name: 'Max' },
-    });
-    store.resetState();
-    expect(getState(store)).toStrictEqual(initialState);
-  });
-
-  it('should not fire if reset is called on unchanged state', () => {
-    const { store } = setup();
-    let effectCounter = 0;
-    TestBed.runInInjectionContext(() => {
-      effect(() => {
-        store.user();
-        effectCounter++;
-      });
-    });
-    TestBed.flushEffects();
-    store.resetState();
-    TestBed.flushEffects();
-    expect(effectCounter).toBe(1);
-  });
-
-  it('should not fire on props which are unchanged', () => {
-    const { store } = setup();
-    let effectCounter = 0;
-    TestBed.runInInjectionContext(() => {
-      effect(() => {
-        store.address();
-        effectCounter++;
-      });
-    });
-
-    TestBed.flushEffects();
-    expect(effectCounter).toBe(1);
-    store.changeUserName('Max');
-    TestBed.flushEffects();
-    store.changeUser(2, 'Ludwig');
-    TestBed.flushEffects();
-    expect(effectCounter).toBe(1);
-  });
-
-  it('should be possible to change the reset state', () => {
-    const { store } = setup();
-
-    setResetState(store, {
-      user: { id: 2, name: 'Max' },
-      address: { city: 'London', zip: 'SW1' },
-    });
-
-    store.changeUser(3, 'Ludwig');
-    store.changeAddress('Paris', '75001');
-
-    store.resetState();
-    expect(getState(store)).toEqual({
-      user: { id: 2, name: 'Max' },
-      address: { city: 'London', zip: 'SW1' },
-    });
-  });
-
-  it('should throw on setResetState if store is not configured with withReset()', () => {
-    const Store = signalStore({ providedIn: 'root' }, withState({}));
-    const store = TestBed.inject(Store);
-    expect(() => setResetState(store, {})).toThrow(
-      'Cannot set reset state, since store is not configured with withReset()',
-    );
-  });
-});

package/src/lib/with-reset.ts

@@ -1,62 +0,0 @@
-import {
-  getState,
-  patchState,
-  signalStoreFeature,
-  StateSource,
-  withHooks,
-  withMethods,
-  withProps,
-} from '@ngrx/signals';
-
-export type PublicMethods = {
-  resetState(): void;
-};
-
-/**
- * Adds a `resetState` method to the store, which resets the state
- * to the initial state.
- *
- * If you want to set a custom initial state, you can use {@link setResetState}.
- */
-export function withReset() {
-  return signalStoreFeature(
-    withProps(() => ({ _resetState: { value: {} } })),
-    withMethods((store): PublicMethods => {
-      // workaround to TS excessive property check
-      const methods = {
-        resetState() {
-          patchState(store, store._resetState.value);
-        },
-        __setResetState__(state: object) {
-          store._resetState.value = state;
-        },
-      };
-
-      return methods;
-    }),
-    withHooks((store) => ({
-      onInit() {
-        store._resetState.value = getState(store);
-      },
-    })),
-  );
-}
-
-/**
- * Sets the reset state of the store to the given state.
- *
- * Throws an error if the store is not configured with {@link withReset}.
- * @param store the instance of a SignalStore
- * @param state the state to set as the reset state
- */
-export function setResetState<State extends object>(
-  store: StateSource<State>,
-  state: State,
-): void {
-  if (!('__setResetState__' in store)) {
-    throw new Error(
-      'Cannot set reset state, since store is not configured with withReset()',
-    );
-  }
-  (store.__setResetState__ as (state: State) => void)(state);
-}