fix: retrict withCalls functions to only allow up to one param

This adds a type restriction to only allow one param in functions declared in the wihCalls config,
necessary because we transfom the fucntion inside an rxMethod which only supports having one param

Fix #78

libs/ngrx-traits/signals/src/lib/with-calls/with-calls.model.ts

@@ -1,22 +1,22 @@
 import { Signal } from '@angular/core';
 import { Observable } from 'rxjs';
 
-export type Call<Params extends readonly any[] = any[], Result = any> = (
-  ...args: Params
-) => Observable<Result> | Promise<Result>;
+export type Call<Param extends any = any, Result = any> =
+  | (() => Observable<Result> | Promise<Result>)
+  | ((arg: Param) => Observable<Result> | Promise<Result>);
 export type CallConfig<
-  Params extends readonly any[] = any[],
+  Param = any,
   Result = any,
   PropName extends string = string,
   Error = any,
 > = {
-  call: Call<Params, Result>;
+  call: Call<Param, Result>;
   resultProp: PropName;
   mapPipe?: 'switchMap' | 'concatMap' | 'exhaustMap';
   storeResult?: boolean;
-  onSuccess?: (result: Result, param: Params[0]) => void;
-  mapError?: (error: unknown, param: Params[0]) => Error;
-  onError?: (error: Error, param: Params[0]) => void;
+  onSuccess?: (result: Result, param: Param) => void;
+  mapError?: (error: unknown, param: Param) => Error;
+  onError?: (error: Error, param: Param) => void;
 };
 export type ExtractCallResultType<T extends Call | CallConfig> =
   T extends Call<any, infer R>
@@ -25,7 +25,7 @@ export type ExtractCallResultType<T extends Call | CallConfig> =
       ? R
       : never;
 export type ExtractCallParams<T extends Call | CallConfig> =
-  T extends Call<infer P> ? P : T extends CallConfig<infer P> ? P : [];
+  T extends Call<infer P> ? P : T extends CallConfig<infer P> ? P : undefined;
 
 export type NamedCallsStatusComputed<Prop extends string> = {
   [K in Prop as `is${Capitalize<string & K>}Loading`]: Signal<boolean>;

libs/ngrx-traits/signals/src/lib/with-calls/with-calls.ts

@@ -127,14 +127,14 @@ export function withCalls<
     signals: NamedCallsStatusComputed<keyof Calls & string> &
       NamedCallsStatusErrorComputed<Calls>;
     methods: {
-      [K in keyof Calls]: ExtractCallParams<Calls[K]> extends []
+      [K in keyof Calls]: Calls[K] extends (() => any) | CallConfig<undefined>
         ? { (): void }
         : {
             (
               param:
-                | ExtractCallParams<Calls[K]>[0]
-                | Observable<ExtractCallParams<Calls[K]>[0]>
-                | Signal<ExtractCallParams<Calls[K]>[0]>,
+                | ExtractCallParams<Calls[K]>
+                | Observable<ExtractCallParams<Calls[K]>>
+                | Signal<ExtractCallParams<Calls[K]>>,
             ): void;
           };
     };
@@ -286,18 +286,18 @@ const mapPipes = {
 };
 
 export function typedCallConfig<
-  Params extends readonly any[] = any[],
+  Param extends any = undefined,
   Result = any,
   PropName extends string = '',
   Error = unknown,
-  C extends CallConfig<Params, Result, PropName, Error> = CallConfig<
-    Params,
+  C extends CallConfig<Param, Result, PropName, Error> = CallConfig<
+    Param,
     Result,
     PropName,
     Error
   >,
 >(
-  config: Omit<CallConfig<Params, Result, PropName, Error>, 'resultProp'> & {
+  config: Omit<CallConfig<Param, Result, PropName, Error>, 'resultProp'> & {
     resultProp?: PropName;
   },
 ) {