@angular-architects/ngrx-toolkit 19.4.0 → 19.4.2

package/lib/devtools/internal/glitch-tracker.service.d.ts

@@ -0,0 +1,18 @@
+import { StateSource } from '@ngrx/signals';
+import { Tracker, TrackerStores } from './models';
+import * as i0 from "@angular/core";
+/**
+ * Internal Service used by {@link withGlitchTracking}. It does not rely
+ * on `effect` as {@link DefaultTracker} does but uses the NgRx function
+ * `watchState` to track all state changes.
+ */
+export declare class GlitchTrackerService implements Tracker {
+    #private;
+    get stores(): TrackerStores;
+    onChange(callback: (changedState: Record<string, object>) => void): void;
+    removeStore(id: string): void;
+    track(id: string, store: StateSource<object>): void;
+    notifyRenamedStore(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlitchTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlitchTrackerService>;
+}

package/lib/devtools/internal/models.d.ts

@@ -0,0 +1,24 @@
+import { StateSource } from '@ngrx/signals';
+import { ReduxDevtoolsConfig } from '../provide-devtools-config';
+import { DevtoolsInnerOptions } from './devtools-feature';
+export type Action = {
+    type: string;
+};
+export type Connection = {
+    send: (action: Action, state: Record<string, unknown>) => void;
+};
+export type ReduxDevtoolsExtension = {
+    connect: (options: ReduxDevtoolsConfig) => Connection;
+};
+export type StoreRegistry = Record<string, {
+    options: DevtoolsInnerOptions;
+    name: string;
+}>;
+export type Tracker = {
+    track(id: string, store: StateSource<object>): void;
+    onChange(callback: (changedState: Record<string, object>) => void): void;
+    notifyRenamedStore(id: string): void;
+    removeStore(id: string): void;
+    get stores(): TrackerStores;
+};
+export type TrackerStores = Record<string, StateSource<object>>;

package/{src/lib/devtools/provide-devtools-config.ts → lib/devtools/provide-devtools-config.d.ts}

@@ -1,24 +1,12 @@
 import { InjectionToken, ValueProvider } from '@angular/core';
-
 /**
  * Provides the configuration options for connecting to the Redux DevTools Extension.
  */
-export function provideDevtoolsConfig(
-  config: ReduxDevtoolsConfig,
-): ValueProvider {
-  return {
-    provide: REDUX_DEVTOOLS_CONFIG,
-    useValue: config,
-  };
-}
-
+export declare function provideDevtoolsConfig(config: ReduxDevtoolsConfig): ValueProvider;
 /**
  * Injection token for the configuration options for connecting to the Redux DevTools Extension.
  */
-export const REDUX_DEVTOOLS_CONFIG = new InjectionToken<ReduxDevtoolsConfig>(
-  'ReduxDevtoolsConfig',
-);
-
+export declare const REDUX_DEVTOOLS_CONFIG: InjectionToken<ReduxDevtoolsConfig>;
 /**
  * Options for connecting to the Redux DevTools Extension.
  * @example
@@ -27,6 +15,6 @@ export const REDUX_DEVTOOLS_CONFIG = new InjectionToken<ReduxDevtoolsConfig>(
  * };
  */
 export type ReduxDevtoolsConfig = {
-  /** Optional name for the devtools instance. If empty, "NgRx SignalStore" will be used. */
-  name?: string;
+    /** Optional name for the devtools instance. If empty, "NgRx SignalStore" will be used. */
+    name?: string;
 };

package/lib/devtools/rename-devtools-name.d.ts

@@ -0,0 +1,7 @@
+import { StateSource } from '@ngrx/signals';
+/**
+ * Renames the name of a store how it appears in the Devtools.
+ * @param store instance of the SignalStore
+ * @param newName new name for the Devtools
+ */
+export declare function renameDevtoolsName<State extends object>(store: StateSource<State>, newName: string): void;

package/lib/devtools/update-state.d.ts

@@ -0,0 +1,15 @@
+import { patchState as originalPatchState, PartialStateUpdater, WritableStateSource } from '@ngrx/signals';
+type PatchFn = typeof originalPatchState extends (arg1: infer First, ...args: infer Rest) => infer Returner ? (state: First, action: string, ...rest: Rest) => Returner : never;
+/**
+ * @deprecated Has been renamed to `updateState`
+ */
+export declare const patchState: PatchFn;
+/**
+ * Wrapper of `patchState` for DevTools integration. Next to updating the state,
+ * it also sends the action to the DevTools.
+ * @param stateSource state of Signal Store
+ * @param action name of action how it will show in DevTools
+ * @param updaters updater functions or objects
+ */
+export declare function updateState<State extends object>(stateSource: WritableStateSource<State>, action: string, ...updaters: Array<Partial<NoInfer<State>> | PartialStateUpdater<NoInfer<State>>>): void;
+export {};

package/{src/lib/devtools/with-dev-tools-stub.ts → lib/devtools/with-dev-tools-stub.d.ts}

@@ -1,6 +1,5 @@
 import { withDevtools } from './with-devtools';
-
 /**
  * Stub for DevTools integration. Can be used to disable DevTools in production.
  */
-export const withDevToolsStub: typeof withDevtools = () => (store) => store;
+export declare const withDevToolsStub: typeof withDevtools;

package/lib/devtools/with-devtools.d.ts

@@ -0,0 +1,24 @@
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+import { DevtoolsFeature } from './internal/devtools-feature';
+import { ReduxDevtoolsExtension } from './internal/models';
+declare global {
+    interface Window {
+        __REDUX_DEVTOOLS_EXTENSION__: ReduxDevtoolsExtension | undefined;
+    }
+}
+export declare const renameDevtoolsMethodName = "___renameDevtoolsName";
+export declare const uniqueDevtoolsId = "___uniqueDevtoolsId";
+/**
+ * Adds this store as a feature state to the Redux DevTools.
+ *
+ * By default, the action name is 'Store Update'. You can
+ * change that via the {@link updateState} method, which has as second
+ * parameter the action name.
+ *
+ * The standalone function {@link renameDevtoolsName} can rename
+ * the store name.
+ *
+ * @param name name of the store as it should appear in the DevTools
+ * @param features features to extend or modify the behavior of the Devtools
+ */
+export declare function withDevtools(name: string, ...features: DevtoolsFeature[]): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult>;

package/lib/flattening-operator.d.ts

@@ -0,0 +1,14 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from 'rxjs';
+export type RxJsFlatteningOperator = <T, O extends ObservableInput<unknown>>(project: (value: T, index: number) => O) => OperatorFunction<T, ObservedValueOf<O>>;
+/**
+ * A wrapper for an RxJS flattening operator.
+ * This wrapper informs about whether the operator has exhaust semantics or not.
+ */
+export type FlatteningOperator = {
+    rxJsOperator: RxJsFlatteningOperator;
+    exhaustSemantics: boolean;
+};
+export declare const switchOp: FlatteningOperator;
+export declare const mergeOp: FlatteningOperator;
+export declare const concatOp: FlatteningOperator;
+export declare const exhaustOp: FlatteningOperator;

package/lib/immutable-state/deep-freeze.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Deep freezes a state object along its properties with primitive values
+ * on the first level.
+ *
+ * The reason for this is that the final state is a merge of all
+ * root properties of all states, i.e. `withState`,....
+ *
+ * Since the root object will not be part of the state (shadow clone),
+ * we are not freezing it.
+ */
+export declare function deepFreeze<T extends Record<string | symbol, unknown>>(target: T, propertyNamesToBeFrozen: (string | symbol)[], isRoot?: boolean): void;

package/lib/immutable-state/is-dev-mode.d.ts

@@ -0,0 +1 @@
+export declare function isDevMode(): boolean;

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/mutation/http-mutation.d.ts

@@ -0,0 +1,86 @@
+import { HttpContext, HttpHeaders, HttpParams, HttpProgressEvent } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { Mutation } from './mutation';
+import { RxMutationOptions } from './rx-mutation';
+export type HttpMutationRequest = {
+    url: string;
+    method: string;
+    body?: unknown;
+    headers?: HttpHeaders | Record<string, string | string[]>;
+    context?: HttpContext;
+    reportProgress?: boolean;
+    params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
+    withCredentials?: boolean;
+    credentials?: RequestCredentials;
+    keepalive?: boolean;
+    priority?: RequestPriority;
+    cache?: RequestCache;
+    mode?: RequestMode;
+    redirect?: RequestRedirect;
+    transferCache?: {
+        includeHeaders?: string[];
+    } | boolean;
+};
+export type HttpMutationOptions<Parameter, Result> = Omit<RxMutationOptions<Parameter, NoInfer<Result>>, 'operation'> & {
+    request: (param: Parameter) => HttpMutationRequest;
+    parse?: (response: unknown) => Result;
+};
+export type HttpMutation<Parameter, Result> = Mutation<Parameter, Result> & {
+    uploadProgress: Signal<HttpProgressEvent | undefined>;
+    downloadProgress: Signal<HttpProgressEvent | undefined>;
+    headers: Signal<HttpHeaders | undefined>;
+    statusCode: Signal<string | undefined>;
+};
+/**
+ * Creates an HTTP mutation.
+ *
+ * export type Params = {
+ *   value: number;
+ * };
+ *
+ * export type CounterResponse = {
+ *   // httpbin.org echos the request using the
+ *   // json property
+ *   json: { counter: number };
+ * };
+ *
+ * const simpleSaveUser = httpMutation({
+ *   request: (userData: AddUserEntry) => ({
+ *     url: 'api/users',
+ *     body: userData,
+ *   }),
+ *   parse: Boolean,
+ * })
+ *
+ * const saveUser = httpMutation({
+ *   request: (p: Params) => ({
+ *     url: `https://httpbin.org/post`,
+ *     method: 'POST',
+ *     body: { counter: p.value },
+ *     headers: { 'Content-Type': 'application/json' },
+ *   }),
+ *   onSuccess: (response: CounterResponse) => {
+ *     console.log('Counter sent to server:', response);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Failed to send counter:', error);
+ *   },
+ * });
+ *
+ * ...
+ *
+ * const result = await this.saveUser({ value: 17 });
+ * if (result.status === 'success') {
+ *   console.log('Successfully saved to server:', result.value);
+ * }
+ * else if (result.status === 'error') {
+ *   console.log('Failed to save:', result.error);
+ * }
+ * else {
+ *   console.log('Operation aborted');
+ * }
+ *
+ * @param options The options for the HTTP mutation.
+ * @returns The HTTP mutation.
+ */
+export declare function httpMutation<Parameter, Result>(optionsOrRequest: HttpMutationOptions<Parameter, Result> | ((param: Parameter) => HttpMutationRequest)): HttpMutation<Parameter, Result>;

package/lib/mutation/mutation.d.ts

@@ -0,0 +1,20 @@
+import { Signal } from '@angular/core';
+export type MutationResult<Result> = {
+    status: 'success';
+    value: Result;
+} | {
+    status: 'error';
+    error: unknown;
+} | {
+    status: 'aborted';
+};
+export type MutationStatus = 'idle' | 'pending' | 'error' | 'success';
+export type Mutation<Parameter, Result> = {
+    (params: Parameter): Promise<MutationResult<Result>>;
+    status: Signal<MutationStatus>;
+    value: Signal<Result | undefined>;
+    isPending: Signal<boolean>;
+    isSuccess: Signal<boolean>;
+    error: Signal<unknown>;
+    hasValue(): this is Mutation<Exclude<Parameter, undefined>, Result>;
+};

package/lib/mutation/rx-mutation.d.ts

@@ -0,0 +1,76 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FlatteningOperator } from '../flattening-operator';
+import { Mutation } from './mutation';
+export type Operation<Parameter, Result> = (param: Parameter) => Result;
+export interface RxMutationOptions<Parameter, Result> {
+    operation: Operation<Parameter, Observable<Result>>;
+    onSuccess?: (result: Result, param: Parameter) => void;
+    onError?: (error: unknown, param: Parameter) => void;
+    operator?: FlatteningOperator;
+    injector?: Injector;
+}
+/**
+ * Creates a mutation that leverages RxJS.
+ *
+ * For each mutation the following options can be defined:
+ * - `operation`: A function that defines the mutation logic. It returns an Observable.
+ * - `onSuccess`: A callback that is called when the mutation is successful.
+ * - `onError`: A callback that is called when the mutation fails.
+ * - `operator`: An optional wrapper of an RxJS flattening operator. By default `concat` sematics are used.
+ * - `injector`: An optional Angular injector to use for dependency injection.
+ *
+ * The `operation` is the only mandatory option.
+ *
+ * The returned mutation can be called as an async function and returns a Promise.
+ * This promise informs about whether the mutation was successful, failed, or aborted
+ * (due to switchMap or exhaustMap semantics).
+ *
+ * The mutation also provides several Signals such as error, status or isPending (see below).
+ *
+ * Example usage without Store:
+ *
+ * ```typescript
+ * const counterSignal = signal(0);
+ *
+ * const increment = rxMutation({
+ *   operation: (param: Param) => {
+ *     return calcSum(this.counterSignal(), param.value);
+ *   },
+ *   operator: concatOp,
+ *   onSuccess: (result) => {
+ *     this.counterSignal.set(result);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Error occurred:', error);
+ *   },
+ * });
+ *
+ * const error = increment.error;
+ * const isPending = increment.isPending;
+ * const status = increment.status;
+ * const value = increment.value;
+ * const hasValue = increment.hasValue;
+ *
+ * async function incrementCounter() {
+ *     const result = await increment({ value: 1 });
+ *     if (result.status === 'success') {
+ *       console.log('Success:', result.value);
+ *     }
+ *     if (result.status === 'error') {
+ *       console.log('Error:', result.error);
+ *     }
+ *     if (result.status === 'aborted') {
+ *       console.log('Operation aborted');
+ *     }
+ * }
+ *
+ * function calcSum(a: number, b: number): Observable<number> {
+ *   return of(result).pipe(delay(500));
+ * }
+ * ```
+ *
+ * @param options
+ * @returns the actual mutation function along tracking data as properties/methods
+ */
+export declare function rxMutation<Parameter, Result>(optionsOrOperation: RxMutationOptions<Parameter, Result> | Operation<Parameter, Observable<Result>>): Mutation<Parameter, Result>;

package/{src/lib/shared/signal-store-models.ts → lib/shared/signal-store-models.d.ts}

@@ -14,17 +14,13 @@
  */
 import { Signal } from '@angular/core';
 import { EntityId } from '@ngrx/signals/entities';
-
-// withEntites models
 export type EntityState<Entity> = {
-  entityMap: Record<EntityId, Entity>;
-  ids: EntityId[];
+    entityMap: Record<EntityId, Entity>;
+    ids: EntityId[];
 };
-
 export type EntityComputed<Entity> = {
-  entities: Signal<Entity[]>;
+    entities: Signal<Entity[]>;
 };
-
 export type NamedEntityComputed<Entity, Collection extends string> = {
-  [K in keyof EntityComputed<Entity> as `${Collection}${Capitalize<K>}`]: EntityComputed<Entity>[K];
+    [K in keyof EntityComputed<Entity> as `${Collection}${Capitalize<K>}`]: EntityComputed<Entity>[K];
 };

package/lib/shared/throw-if-null.d.ts

@@ -0,0 +1 @@
+export declare function throwIfNull<T>(obj: T): NonNullable<T>;

package/lib/storage-sync/features/with-indexed-db.d.ts

@@ -0,0 +1,2 @@
+import { AsyncStorageStrategy } from '../internal/models';
+export declare function withIndexedDB<State extends object>(): AsyncStorageStrategy<State>;

package/lib/storage-sync/features/with-local-storage.d.ts

@@ -0,0 +1,3 @@
+import { SyncStorageStrategy } from '../internal/models';
+export declare function withLocalStorage<State extends object>(): SyncStorageStrategy<State>;
+export declare function withSessionStorage<State extends object>(): SyncStorageStrategy<State>;

package/lib/storage-sync/internal/indexeddb.service.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export declare const keyPath = "ngrxToolkitKeyPath";
+export declare const dbName = "ngrxToolkitDb";
+export declare const storeName = "ngrxToolkitStore";
+export declare const VERSION: number;
+export declare class IndexedDBService {
+    /**
+     * write to indexedDB
+     * @param key
+     * @param data
+     */
+    setItem(key: string, data: string): Promise<void>;
+    /**
+     * read from indexedDB
+     * @param key
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * delete indexedDB
+     * @param key
+     */
+    clear(key: string): Promise<void>;
+    /**
+     * open indexedDB
+     */
+    private openDB;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBService>;
+}

package/lib/storage-sync/internal/local-storage.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class LocalStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, data: string): void;
+    clear(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}

package/lib/storage-sync/internal/models.d.ts

@@ -0,0 +1,45 @@
+import { Signal, WritableSignal } from '@angular/core';
+import { EmptyFeatureResult, WritableStateSource } from '@ngrx/signals';
+import { SyncConfig } from '../with-storage-sync';
+export type SyncMethods = {
+    clearStorage(): void;
+    readFromStorage(): void;
+    writeToStorage(): void;
+};
+export type SyncFeatureResult = EmptyFeatureResult & {
+    methods: SyncMethods;
+};
+export type SyncStoreForFactory<State extends object> = WritableStateSource<State>;
+export type SyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: SyncStoreForFactory<State>, useStubs: boolean) => SyncMethods) & {
+    type: 'sync';
+};
+export type AsyncMethods = {
+    clearStorage(): Promise<void>;
+    readFromStorage(): Promise<void>;
+    writeToStorage(): Promise<void>;
+};
+/**
+ * AsyncFeatureResult is used as the public interface that users interact with
+ * when calling `withIndexedDB`. It intentionally omits the internal SYNC_STATUS
+ * property to avoid TypeScript error TS4058 (return type of public method
+ * includes private type).
+ *
+ * For internal implementation, we use AsyncStoreForFactory which includes
+ * the SYNC_STATUS property needed for state management.
+ */
+export declare const SYNC_STATUS: unique symbol;
+export type SyncStatus = 'idle' | 'syncing' | 'synced';
+export type InternalAsyncProps = AsyncFeatureResult['props'] & {
+    [SYNC_STATUS]: WritableSignal<SyncStatus>;
+};
+export type AsyncFeatureResult = EmptyFeatureResult & {
+    methods: AsyncMethods;
+    props: {
+        isSynced: Signal<boolean>;
+        whenSynced: () => Promise<void>;
+    };
+};
+export type AsyncStoreForFactory<State extends object> = WritableStateSource<State> & InternalAsyncProps;
+export type AsyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: AsyncStoreForFactory<State>, useStubs: boolean) => AsyncMethods) & {
+    type: 'async';
+};

package/lib/storage-sync/internal/session-storage.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class SessionStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, data: string): void;
+    clear(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
+}

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

@@ -0,0 +1,45 @@
+import { SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
+import { AsyncFeatureResult, AsyncStorageStrategy, SyncFeatureResult, SyncStorageStrategy } from './internal/models';
+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) => unknown;
+    /**
+     * Function used to parse the state coming from storage.
+     *
+     * `JSON.parse()` by default
+     */
+    parse?: (stateString: string) => State;
+    /**
+     * Function used to transform the state into a string representation.
+     *
+     * `JSON.stringify()` by default
+     */
+    stringify?: (state: State) => string;
+    /**
+     * @deprecated Use {@link withSessionStorage} instead.
+     * Factory function used to switch to sessionStorage.
+     *
+     * `localStorage` by default
+     */
+    storage?: () => Storage;
+};
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;

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

@@ -0,0 +1,58 @@
+import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature } 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 declare function deriveCallStateKeys<Collection extends string>(collection?: Collection): {
+    callStateKey: string;
+    loadingKey: string;
+    loadedKey: string;
+    errorKey: string;
+};
+export declare function getCallStateKeys(config?: {
+    collection?: string;
+}): {
+    callStateKey: string;
+    loadingKey: string;
+    loadedKey: string;
+    errorKey: string;
+};
+export declare function getCollectionArray(config: {
+    collection?: string;
+} | {
+    collections?: string[];
+}): string[] | undefined;
+export declare function withCallState<Collection extends string>(config: {
+    collections: Collection[];
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection>;
+    props: NamedCallStateSignals<Collection>;
+}>;
+export declare function withCallState<Collection extends string>(config: {
+    collection: Collection;
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection>;
+    props: NamedCallStateSignals<Collection>;
+}>;
+export declare function withCallState(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: CallStateSlice;
+    props: CallStateSignals;
+}>;
+export declare function setLoading<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
+export declare function setLoaded<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
+export declare function setError<Prop extends string | undefined = undefined>(error: unknown, prop?: Prop): SetCallState<Prop>;