@angular-architects/ngrx-toolkit 0.0.4 → 0.0.7

package/lib/redux-connector/create-redux.d.ts

@@ -0,0 +1,13 @@
+import { ActionCreator, ActionType } from "@ngrx/store/src/models";
+import { CreateReduxState, MapperTypes, Store } from "./model";
+export declare function mapAction<Creators extends readonly ActionCreator[]>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>) => unknown
+]): MapperTypes<Creators>;
+export declare function mapAction<Creators extends readonly ActionCreator[], T>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>, resultMethod: (input: T) => unknown) => unknown,
+    resultMethod: (input: T) => unknown
+]): MapperTypes<Creators>;
+export declare function withActionMappers(...mappers: MapperTypes<ActionCreator<any, any>[]>[]): MapperTypes<ActionCreator<any, any>[]>[];
+export declare function createReduxState<StoreName extends string, STORE extends Store>(storeName: StoreName, signalStore: STORE, withActionMappers: (store: InstanceType<STORE>) => MapperTypes<ActionCreator<any, any>[]>[]): CreateReduxState<StoreName, STORE>;

package/lib/redux-connector/index.d.ts

@@ -0,0 +1 @@
+export { createReduxState, mapAction, withActionMappers } from './create-redux';

package/lib/redux-connector/model.d.ts

@@ -0,0 +1,36 @@
+import { EnvironmentProviders, Signal, Type } from "@angular/core";
+import { DeepSignal } from "@ngrx/signals/src/deep-signal";
+import { SignalStoreFeatureResult } from "@ngrx/signals/src/signal-store-models";
+import { StateSignal } from "@ngrx/signals/src/state-signal";
+import { Action, ActionCreator, ActionType, Prettify } from "@ngrx/store/src/models";
+import { Observable, Unsubscribable } from "rxjs";
+export type IncludePropType<T, V, WithNevers = {
+    [K in keyof T]: Exclude<T[K], undefined> extends V ? T[K] extends Record<string, unknown> ? IncludePropType<T[K], V> : T[K] : never;
+}> = Prettify<Pick<WithNevers, {
+    [K in keyof WithNevers]: WithNevers[K] extends never ? never : K extends string ? K : never;
+}[keyof WithNevers]>>;
+export type Store = Type<Record<string, unknown> & StateSignal<SignalStoreFeatureResult['state']>>;
+export type CreateReduxState<StoreName extends string, STORE extends Store> = {
+    [K in StoreName as `provide${Capitalize<K>}Store`]: (connectReduxDevtools?: boolean) => EnvironmentProviders;
+} & {
+    [K in StoreName as `inject${Capitalize<K>}Store`]: () => InjectableReduxSlice<STORE>;
+};
+export type Selectors<STORE extends Store> = IncludePropType<InstanceType<STORE>, Signal<unknown> | DeepSignal<unknown>>;
+export type Dispatch = {
+    dispatch: (input: Action | Observable<Action> | Signal<Action>) => Unsubscribable;
+};
+export type InjectableReduxSlice<STORE extends Store> = Selectors<STORE> & Dispatch;
+export type ExtractActionTypes<Creators extends readonly ActionCreator[]> = {
+    [Key in keyof Creators]: Creators[Key] extends ActionCreator<infer T> ? T : never;
+};
+export interface ActionMethod<T, V extends Action = Action> {
+    (action: V): T;
+}
+export interface StoreMethod<Creators extends readonly ActionCreator[], ResultState = unknown> {
+    (action: ActionType<Creators[number]>): ResultState;
+}
+export interface MapperTypes<Creators extends readonly ActionCreator[]> {
+    types: ExtractActionTypes<Creators>;
+    storeMethod: StoreMethod<Creators>;
+    resultMethod?: (...args: unknown[]) => unknown;
+}

package/lib/redux-connector/rxjs-interop/index.d.ts

@@ -0,0 +1 @@
+export { reduxMethod } from './redux-method';

package/lib/redux-connector/rxjs-interop/redux-method.d.ts

@@ -0,0 +1,11 @@
+import { Injector, Signal } from "@angular/core";
+import { Observable, Unsubscribable } from "rxjs";
+type RxMethodInput<Input> = Input | Observable<Input> | Signal<Input>;
+type RxMethod<Input, MethodInput = Input, MethodResult = unknown> = ((input: RxMethodInput<Input>, resultMethod: (input: MethodInput) => MethodResult) => Unsubscribable) & Unsubscribable;
+export declare function reduxMethod<Input, MethodInput = Input>(generator: (source$: Observable<Input>) => Observable<MethodInput>, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput>;
+export declare function reduxMethod<Input, MethodInput = Input, MethodResult = unknown>(generator: (source$: Observable<Input>) => Observable<MethodInput>, resultMethod: (input: MethodInput) => MethodResult, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput, MethodResult>;
+export {};

package/lib/redux-connector/signal-redux-store.d.ts

@@ -0,0 +1,11 @@
+import { Action, ActionCreator } from "@ngrx/store";
+import { MapperTypes } from "./model";
+import * as i0 from "@angular/core";
+export declare class SignalReduxStore {
+    private mapperDict;
+    dispatch: ((input: Action | import("rxjs").Observable<Action> | import("@angular/core").Signal<Action>) => import("rxjs").Unsubscribable) & import("rxjs").Unsubscribable;
+    connectFeatureStore(mappers: MapperTypes<ActionCreator<any, any>[]>[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignalReduxStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignalReduxStore>;
+}
+export declare function injectReduxDispatch(): ((input: Action | import("rxjs").Observable<Action> | import("@angular/core").Signal<Action>) => import("rxjs").Unsubscribable) & import("rxjs").Unsubscribable;

package/lib/redux-connector/util.d.ts

@@ -0,0 +1,5 @@
+import { Action } from '@ngrx/store';
+import { Unsubscribable } from 'rxjs';
+export declare function isUnsubscribable<F extends (...args: unknown[]) => unknown>(fn: F | (F & Unsubscribable)): fn is F & Unsubscribable;
+export declare function capitalize(str: string): string;
+export declare function isActionCreator(action: any): action is Action;

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

@@ -22,6 +22,7 @@ export type CallStateSignals = {
     loaded: Signal<boolean>;
     error: Signal<string | null>;
 };
+export type SetCallState<Prop extends string | undefined> = Prop extends string ? NamedCallStateSlice<Prop> : CallStateSlice;
 export declare function getCallStateKeys(config?: {
     collection?: string;
 }): {
@@ -50,6 +51,6 @@ export declare function withCallState(): SignalStoreFeature<{
     signals: CallStateSignals;
     methods: Emtpy;
 }>;
-export declare function setLoading<Prop extends string>(prop?: Prop): NamedCallStateSlice<Prop> | CallStateSlice;
-export declare function setLoaded<Prop extends string>(prop?: Prop): NamedCallStateSlice<Prop> | CallStateSlice;
-export declare function setError<Prop extends string>(error: unknown, prop?: Prop): NamedCallStateSlice<Prop> | CallStateSlice;
+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>;

package/lib/with-redux.d.ts

@@ -29,10 +29,10 @@ type PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {
 export declare function payload<Type extends Payload>(): Type;
 export declare const noPayload: {};
 /** Reducer **/
-type ReducerFunction<ReducerAction, State> = (action: ActionFnPayload<ReducerAction>, state: State) => void;
+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<ActionFnPayload<ReducerAction>, State>) => void) => void;
+}>(action: ReducerAction, reducerFn: ReducerFunction<ReducerAction, State>) => void) => void;
 /** Effect **/
 type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns, create: <EffectAction extends {
     type: string;

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

@@ -0,0 +1,58 @@
+import { SignalStoreFeature } from '@ngrx/signals';
+import { Emtpy } from './shared/empty';
+type SignalStoreFeatureInput<State> = Pick<Parameters<SignalStoreFeature>[0], 'signals' | 'methods'> & {
+    state: State;
+};
+type WithStorageSyncFeatureResult = {
+    state: Emtpy;
+    signals: Emtpy;
+    methods: {
+        clearStorage(): void;
+        readFromStorage(): void;
+        writeToStorage(): void;
+    };
+};
+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 declare function withStorageSync<State extends object, Input extends SignalStoreFeatureInput<State>>(key: string): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
+export declare function withStorageSync<State extends object, Input extends SignalStoreFeatureInput<State>>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, WithStorageSyncFeatureResult>;
+export {};

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@angular-architects/ngrx-toolkit",
-  "version": "0.0.4",
+  "version": "0.0.7",
+  "license": "MIT",
+  "repository": {
+    "type": "GitHub",
+    "url": "https://github.com/angular-architects/ngrx-toolkit"
+  },
   "peerDependencies": {
     "@angular/common": "^17.0.0",
     "@angular/core": "^17.0.0",