@angular-architects/ngrx-toolkit 20.0.2 → 20.0.3

package/src/lib/with-call-state.ts

@@ -1,195 +0,0 @@
-import { Signal, computed } from '@angular/core';
-import {
-  EmptyFeatureResult,
-  SignalStoreFeature,
-  signalStoreFeature,
-  withComputed,
-  withState,
-} from '@ngrx/signals';
-
-export type CallState = 'init' | 'loading' | 'loaded' | { error: string };
-
-export type CallStateSlice = {
-  callState: CallState;
-};
-
-export type NamedCallStateSlice<Collection extends string> = {
-  [K in keyof CallStateSlice as Collection extends ''
-    ? `${Collection}${K}`
-    : `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
-};
-
-export type CallStateSignals = {
-  loading: Signal<boolean>;
-  loaded: Signal<boolean>;
-  error: Signal<string | null>;
-};
-
-export type NamedCallStateSignals<Prop extends string> = {
-  [K in keyof CallStateSignals as Prop extends ''
-    ? `${Prop}${K}`
-    : `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
-};
-
-export type SetCallState<Prop extends string | undefined> = Prop extends string
-  ? NamedCallStateSlice<Prop>
-  : CallStateSlice;
-
-export function deriveCallStateKeys<Collection extends string>(
-  collection?: Collection,
-) {
-  return {
-    callStateKey: collection ? `${collection}CallState` : 'callState',
-    loadingKey: collection ? `${collection}Loading` : 'loading',
-    loadedKey: collection ? `${collection}Loaded` : 'loaded',
-    errorKey: collection ? `${collection}Error` : 'error',
-  };
-}
-
-export function getCallStateKeys(config?: { collection?: string }) {
-  const prop = config?.collection;
-  return deriveCallStateKeys(prop);
-}
-
-export function getCollectionArray(
-  config: { collection?: string } | { collections?: string[] },
-) {
-  return 'collections' in config
-    ? config.collections
-    : 'collection' in config && config.collection
-      ? [config.collection]
-      : undefined;
-}
-
-export function withCallState<Collection extends string>(config: {
-  collections: Collection[];
-}): SignalStoreFeature<
-  EmptyFeatureResult,
-  EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-  }
->;
-export function withCallState<Collection extends string>(config: {
-  collection: Collection;
-}): SignalStoreFeature<
-  EmptyFeatureResult,
-  EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-  }
->;
-export function withCallState(): SignalStoreFeature<
-  EmptyFeatureResult,
-  EmptyFeatureResult & {
-    state: CallStateSlice;
-    props: CallStateSignals;
-  }
->;
-export function withCallState<Collection extends string>(
-  config?:
-    | {
-        collection: Collection;
-      }
-    | {
-        collections: Collection[];
-      },
-): SignalStoreFeature {
-  return signalStoreFeature(
-    withState(() => {
-      if (!config) {
-        return { callState: 'init' };
-      }
-      const collections = getCollectionArray(config);
-      if (collections) {
-        return collections.reduce(
-          (acc, cur) => ({
-            ...acc,
-            ...{ [cur ? `${cur}CallState` : 'callState']: 'init' },
-          }),
-          {},
-        );
-      }
-
-      return { callState: 'init' };
-    }),
-    withComputed((state: Record<string, Signal<unknown>>) => {
-      if (config) {
-        const collections = getCollectionArray(config);
-        if (collections) {
-          return collections.reduce<Record<string, Signal<unknown>>>(
-            (acc, cur: string) => {
-              const { callStateKey, errorKey, loadedKey, loadingKey } =
-                deriveCallStateKeys(cur);
-              const callState = state[callStateKey] as Signal<CallState>;
-              return {
-                ...acc,
-                [loadingKey]: computed(() => callState() === 'loading'),
-                [loadedKey]: computed(() => callState() === 'loaded'),
-                [errorKey]: computed(() => {
-                  const v = callState();
-                  return typeof v === 'object' ? v.error : null;
-                }),
-              };
-            },
-            {},
-          );
-        }
-      }
-      const { callStateKey, errorKey, loadedKey, loadingKey } =
-        deriveCallStateKeys();
-      const callState = state[callStateKey] as Signal<CallState>;
-      return {
-        [loadingKey]: computed(() => callState() === 'loading'),
-        [loadedKey]: computed(() => callState() === 'loaded'),
-        [errorKey]: computed(() => {
-          const v = callState();
-          return typeof v === 'object' ? v.error : null;
-        }),
-      };
-    }),
-  );
-}
-
-export function setLoading<Prop extends string | undefined = undefined>(
-  prop?: Prop,
-): SetCallState<Prop> {
-  if (prop) {
-    return { [`${prop}CallState`]: 'loading' } as SetCallState<Prop>;
-  }
-
-  return { callState: 'loading' } as SetCallState<Prop>;
-}
-
-export function setLoaded<Prop extends string | undefined = undefined>(
-  prop?: Prop,
-): SetCallState<Prop> {
-  if (prop) {
-    return { [`${prop}CallState`]: 'loaded' } as SetCallState<Prop>;
-  } else {
-    return { callState: 'loaded' } as SetCallState<Prop>;
-  }
-}
-
-export function setError<Prop extends string | undefined = undefined>(
-  error: unknown,
-  prop?: Prop,
-): SetCallState<Prop> {
-  let errorMessage: string;
-
-  if (!error) {
-    errorMessage = '';
-  } else if (typeof error === 'object' && 'message' in error) {
-    errorMessage = String(error.message);
-  } else {
-    errorMessage = String(error);
-  }
-
-  if (prop) {
-    return {
-      [`${prop}CallState`]: { error: errorMessage },
-    } as SetCallState<Prop>;
-  } else {
-    return { callState: { error: errorMessage } } as SetCallState<Prop>;
-  }
-}

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

@@ -1,125 +0,0 @@
-import { inject, InjectionToken } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import {
-  getState,
-  patchState,
-  signalStore,
-  signalStoreFeature,
-  withHooks,
-  withMethods,
-  withState,
-} from '@ngrx/signals';
-import { withDevtools } from './devtools/with-devtools';
-import { emptyFeature, withConditional } from './with-conditional';
-
-describe('withConditional', () => {
-  const withUser = signalStoreFeature(
-    withState({ id: 0, name: '' }),
-    withHooks((store) => ({
-      onInit() {
-        patchState(store, { id: 1, name: 'Konrad' });
-      },
-    })),
-  );
-
-  const withFakeUser = signalStoreFeature(
-    withState({ id: 0, name: 'Tommy Fake' }),
-  );
-
-  for (const isReal of [true, false]) {
-    it(`should ${isReal ? '' : 'not '} enable withUser`, () => {
-      const REAL_USER_TOKEN = new InjectionToken('REAL_USER', {
-        providedIn: 'root',
-        factory: () => isReal,
-      });
-      const UserStore = signalStore(
-        { providedIn: 'root' },
-        withConditional(() => inject(REAL_USER_TOKEN), withUser, withFakeUser),
-      );
-      const userStore = TestBed.inject(UserStore);
-
-      if (isReal) {
-        expect(getState(userStore)).toEqual({ id: 1, name: 'Konrad' });
-      } else {
-        expect(getState(userStore)).toEqual({ id: 0, name: 'Tommy Fake' });
-      }
-    });
-  }
-
-  it(`should access the store`, () => {
-    const UserStore = signalStore(
-      { providedIn: 'root' },
-      withMethods(() => ({
-        useRealUser: () => true,
-      })),
-      withConditional((store) => store.useRealUser(), withUser, withFakeUser),
-    );
-    const userStore = TestBed.inject(UserStore);
-
-    expect(getState(userStore)).toEqual({ id: 1, name: 'Konrad' });
-  });
-
-  it('should be used inside a signalStoreFeature', () => {
-    const withConditionalUser = (activate: boolean) =>
-      signalStoreFeature(
-        withConditional(() => activate, withUser, withFakeUser),
-      );
-
-    const UserStore = signalStore(
-      { providedIn: 'root' },
-      withConditionalUser(true),
-    );
-    const userStore = TestBed.inject(UserStore);
-
-    expect(getState(userStore)).toEqual({ id: 1, name: 'Konrad' });
-  });
-
-  it('should ensure that both features return the same type', () => {
-    const withUser = signalStoreFeature(
-      withState({ id: 0, name: '' }),
-      withHooks((store) => ({
-        onInit() {
-          patchState(store, { id: 1, name: 'Konrad' });
-        },
-      })),
-    );
-
-    const withFakeUser = signalStoreFeature(
-      withState({ id: 0, firstname: 'Tommy Fake' }),
-    );
-
-    // @ts-expect-error withFakeUser has a different state shape
-    signalStore(withConditional(() => true, withUser, withFakeUser));
-  });
-
-  it('should also work with empty features', () => {
-    signalStore(
-      withConditional(
-        () => true,
-        withDevtools('dummy'),
-        signalStoreFeature(withState({})),
-      ),
-    );
-  });
-
-  it('should work with `emptyFeature` if falsy is skipped', () => {
-    signalStore(
-      withConditional(
-        () => true,
-        signalStoreFeature(withState({})),
-        emptyFeature,
-      ),
-    );
-  });
-
-  it('should not work with `emptyFeature` if feature is not empty', () => {
-    signalStore(
-      withConditional(
-        () => true,
-        // @ts-expect-error feature is not empty
-        () => signalStoreFeature(withState({ x: 1 })),
-        emptyFeature,
-      ),
-    );
-  });
-});

package/src/lib/with-conditional.ts

@@ -1,74 +0,0 @@
-import {
-  signalStoreFeature,
-  SignalStoreFeature,
-  SignalStoreFeatureResult,
-  StateSignals,
-  withState,
-} 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 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> {
-  return (store) => {
-    const conditionStore = {
-      ...store['stateSignals'],
-      ...store['props'],
-      ...store['methods'],
-    };
-    return condition(conditionStore)
-      ? featureIfTrue(store)
-      : featureIfFalse(store);
-  };
-}
-
-export const emptyFeature = signalStoreFeature(withState({}));