@angular-architects/ngrx-toolkit 0.1.0 → 0.1.2

package/src/lib/with-redux.ts

@@ -1,261 +0,0 @@
-import { Observable, Subject } from 'rxjs';
-import { SignalStoreFeature } from '@ngrx/signals';
-import {
-  EmptyFeatureResult,
-  SignalStoreFeatureResult,
-} from '@ngrx/signals/src/signal-store-models';
-import { StateSignal } from '@ngrx/signals/src/state-signal';
-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]: ((
-    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;
-
-/** Effect **/
-
-type EffectsFactory<StateActionFns extends ActionFns> = (
-  actions: StateActionFns,
-  create: <EffectAction extends { type: string }>(
-    action: EffectAction
-  ) => Observable<ActionFnPayload<EffectAction>>
-) => Record<string, Observable<unknown>>;
-
-function createActionFns<Spec extends ActionsFnSpecs>(
-  actionFnSpecs: Spec,
-  reducerRegistry: Record<
-    string,
-    (state: unknown, payload: ActionFnPayload<unknown>) => void
-  >,
-  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,
-  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 effectSubject = effectsRegistry[type];
-      if (effectSubject) {
-        (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: Record<string, Subject<ActionFnPayload<unknown>>>,
-  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: Record<string, Subject<ActionFnPayload<unknown>>> = {}
-): Observable<unknown>[] {
-  function create(action: { type: string }) {
-    const subject = new Subject<ActionFnPayload<unknown>>();
-    effectsRegistry[action.type] = 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, StateSignal<Input['state']>>;
-  effects: EffectsFactory<StateActionFns>;
-}): SignalStoreFeature<
-  Input,
-  EmptyFeatureResult & { methods: PublicStoreActionFns }
-> {
-  return (store) => {
-    const { methods, subscriptions } = processRedux<Spec, PublicStoreActionFns>(
-      redux.actions,
-      redux.reducer as ReducerFactory<ActionFns, unknown>,
-      redux.effects as EffectsFactory<ActionFns>,
-      store
-    );
-    return {
-      ...store,
-      methods,
-    };
-  };
-}

package/src/lib/with-storage-sync.spec.ts

@@ -1,237 +0,0 @@
-import { getState, patchState, signalStore, withState } from '@ngrx/signals';
-import { withStorageSync } from './with-storage-sync';
-import { TestBed } from '@angular/core/testing';
-
-interface StateObject {
-  foo: string;
-  age: number;
-}
-const initialState: StateObject = {
-  foo: 'bar',
-  age: 18,
-};
-const key = 'FooBar';
-
-describe('withStorageSync', () => {
-  beforeEach(() => {
-    // make sure to start with a clean storage
-    localStorage.removeItem(key);
-  });
-
-  it('adds methods for storage access to the store', () => {
-    TestBed.runInInjectionContext(() => {
-      const Store = signalStore(withStorageSync({ key }));
-      const store = new Store();
-
-      expect(Object.keys(store)).toEqual([
-        'clearStorage',
-        'readFromStorage',
-        'writeToStorage',
-      ]);
-    });
-  });
-
-  it('offers manual sync using provided methods', () => {
-    TestBed.runInInjectionContext(() => {
-      // prefill storage
-      localStorage.setItem(
-        key,
-        JSON.stringify({
-          foo: 'baz',
-          age: 99,
-        } as StateObject)
-      );
-
-      const Store = signalStore(withStorageSync({ key, autoSync: false }));
-      const store = new Store();
-      expect(getState(store)).toEqual({});
-
-      store.readFromStorage();
-      expect(getState(store)).toEqual({
-        foo: 'baz',
-        age: 99,
-      });
-
-      patchState(store, { ...initialState });
-      TestBed.flushEffects();
-
-      let storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-      expect(storeItem).toEqual({
-        foo: 'baz',
-        age: 99,
-      });
-
-      store.writeToStorage();
-      storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-      expect(storeItem).toEqual({
-        ...initialState,
-      });
-
-      store.clearStorage();
-      storeItem = localStorage.getItem(key);
-      expect(storeItem).toEqual(null);
-    });
-  });
-
-  describe('autoSync', () => {
-    it('inits from storage and write to storage on changes when set to `true`', () => {
-      TestBed.runInInjectionContext(() => {
-        // prefill storage
-        localStorage.setItem(
-          key,
-          JSON.stringify({
-            foo: 'baz',
-            age: 99,
-          } as StateObject)
-        );
-
-        const Store = signalStore(withStorageSync(key));
-        const store = new Store();
-        expect(getState(store)).toEqual({
-          foo: 'baz',
-          age: 99,
-        });
-
-        patchState(store, { ...initialState });
-        TestBed.flushEffects();
-
-        expect(getState(store)).toEqual({
-          ...initialState,
-        });
-        const storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-        expect(storeItem).toEqual({
-          ...initialState,
-        });
-      });
-    });
-
-    it('does not init from storage and does write to storage on changes when set to `false`', () => {
-      TestBed.runInInjectionContext(() => {
-        // prefill storage
-        localStorage.setItem(
-          key,
-          JSON.stringify({
-            foo: 'baz',
-            age: 99,
-          } as StateObject)
-        );
-
-        const Store = signalStore(withStorageSync({ key, autoSync: false }));
-        const store = new Store();
-        expect(getState(store)).toEqual({});
-
-        patchState(store, { ...initialState });
-        const storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-        expect(storeItem).toEqual({
-          foo: 'baz',
-          age: 99,
-        });
-      });
-    });
-  });
-
-  describe('select', () => {
-    it('syncs the whole state by default', () => {
-      TestBed.runInInjectionContext(() => {
-        const Store = signalStore(withStorageSync(key));
-        const store = new Store();
-
-        patchState(store, { ...initialState });
-        TestBed.flushEffects();
-
-        const storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-        expect(storeItem).toEqual({
-          ...initialState,
-        });
-      });
-    });
-
-    it('syncs selected slices when specified', () => {
-      TestBed.runInInjectionContext(() => {
-        const Store = signalStore(
-          withState(initialState),
-          withStorageSync({ key, select: ({ foo }) => ({ foo }) })
-        );
-        const store = new Store();
-
-        patchState(store, { foo: 'baz' });
-        TestBed.flushEffects();
-
-        const storeItem = JSON.parse(localStorage.getItem(key) || '{}');
-        expect(storeItem).toEqual({
-          foo: 'baz',
-        });
-      });
-    });
-  });
-
-  describe('parse/stringify', () => {
-    it('uses custom parsing/stringification when specified', () => {
-      const parse = (stateString: string) => {
-        const [foo, age] = stateString.split('_');
-        return {
-          foo,
-          age: +age,
-        };
-      };
-
-      TestBed.runInInjectionContext(() => {
-        const Store = signalStore(
-          withState(initialState),
-          withStorageSync({
-            key,
-            parse,
-            stringify: (state) => `${state.foo}_${state.age}`,
-          })
-        );
-        const store = new Store();
-
-        patchState(store, { foo: 'baz' });
-        TestBed.flushEffects();
-
-        const storeItem = parse(localStorage.getItem(key) || '');
-        expect(storeItem).toEqual({
-          ...initialState,
-          foo: 'baz',
-        });
-      });
-    });
-  });
-
-  describe('storage factory', () => {
-    it('uses specified storage', () => {
-      TestBed.runInInjectionContext(() => {
-        // prefill storage
-        sessionStorage.setItem(
-          key,
-          JSON.stringify({
-            foo: 'baz',
-            age: 99,
-          } as StateObject)
-        );
-
-        const Store = signalStore(
-          withStorageSync({ key, storage: () => sessionStorage })
-        );
-        const store = new Store();
-        expect(getState(store)).toEqual({
-          foo: 'baz',
-          age: 99,
-        });
-
-        patchState(store, { ...initialState });
-        TestBed.flushEffects();
-
-        expect(getState(store)).toEqual({
-          ...initialState,
-        });
-        const storeItem = JSON.parse(sessionStorage.getItem(key) || '{}');
-        expect(storeItem).toEqual({
-          ...initialState,
-        });
-
-        store.clearStorage();
-      });
-    });
-  });
-});

package/src/lib/with-storage-sync.ts

@@ -1,160 +0,0 @@
-import { isPlatformServer } from '@angular/common';
-import { PLATFORM_ID, effect, inject } from '@angular/core';
-import {
-  SignalStoreFeature,
-  getState,
-  patchState,
-  signalStoreFeature,
-  withHooks,
-  withMethods,
-} from '@ngrx/signals';
-import { Emtpy } from './shared/empty';
-
-type SignalStoreFeatureInput<State> = Pick<
-  Parameters<SignalStoreFeature>[0],
-  'signals' | 'methods'
-> & {
-  state: State;
-};
-
-const NOOP = () => {};
-
-type WithStorageSyncFeatureResult = {
-  state: Emtpy;
-  signals: Emtpy;
-  methods: {
-    clearStorage(): void;
-    readFromStorage(): void;
-    writeToStorage(): void;
-  };
-};
-
-const StorageSyncStub: Pick<
-  WithStorageSyncFeatureResult,
-  'methods'
->['methods'] = {
-  clearStorage: NOOP,
-  readFromStorage: NOOP,
-  writeToStorage: NOOP,
-};
-
-export type SyncConfig<State> = {
-  /**
-   * The key which is used to access the storage.
-   */
-  key: string;
-  /**
-   * Flag indicating if the store should read from storage on init and write to storage on every state change.
-   *
-   * `true` by default
-   */
-  autoSync?: boolean;
-  /**
-   * Function to select that portion of the state which should be stored.
-   *
-   * Returns the whole state object by default
-   */
-  select?: (state: State) => Partial<State>;
-  /**
-   * Function used to parse the state coming from storage.
-   *
-   * `JSON.parse()` by default
-   */
-  parse?: (stateString: string) => State;
-  /**
-   * Function used to tranform the state into a string representation.
-   *
-   * `JSON.stringify()` by default
-   */
-  stringify?: (state: State) => string;
-  /**
-   * Factory function used to select the storage.
-   *
-   * `localstorage` by default
-   */
-  storage?: () => Storage;
-};
-
-/**
- * Enables store synchronization with storage.
- *
- * Only works on browser platform.
- */
-export function withStorageSync<
-  State extends object,
-  Input extends SignalStoreFeatureInput<State>
->(key: string): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
-export function withStorageSync<
-  State extends object,
-  Input extends SignalStoreFeatureInput<State>
->(
-  config: SyncConfig<Input['state']>
-): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
-export function withStorageSync<
-  State extends object,
-  Input extends SignalStoreFeatureInput<State>
->(
-  configOrKey: SyncConfig<Input['state']> | string
-): SignalStoreFeature<Input, WithStorageSyncFeatureResult> {
-  const {
-    key,
-    autoSync = true,
-    select = (state: State) => state,
-    parse = JSON.parse,
-    stringify = JSON.stringify,
-    storage: storageFactory = () => localStorage,
-  } = typeof configOrKey === 'string' ? { key: configOrKey } : configOrKey;
-
-  return signalStoreFeature(
-    withMethods((store, platformId = inject(PLATFORM_ID)) => {
-      if (isPlatformServer(platformId)) {
-        console.warn(
-          `'withStorageSync' provides non-functional implementation due to server-side execution`
-        );
-        return StorageSyncStub;
-      }
-
-      const storage = storageFactory();
-
-      return {
-        /**
-         * Removes the item stored in storage.
-         */
-        clearStorage(): void {
-          storage.removeItem(key);
-        },
-        /**
-         * Reads item from storage and patches the state.
-         */
-        readFromStorage(): void {
-          const stateString = storage.getItem(key);
-          if (stateString) {
-            patchState(store, parse(stateString));
-          }
-        },
-        /**
-         * Writes selected portion to storage.
-         */
-        writeToStorage(): void {
-          const slicedState = select(getState(store) as State);
-          storage.setItem(key, stringify(slicedState));
-        },
-      };
-    }),
-    withHooks({
-      onInit(store, platformId = inject(PLATFORM_ID)) {
-        if (isPlatformServer(platformId)) {
-          return;
-        }
-
-        if (autoSync) {
-          store.readFromStorage();
-
-          effect(() => {
-            store.writeToStorage();
-          });
-        }
-      },
-    })
-  );
-}