@ngrx-traits/core 19.2.2 → 20.0.0-beta.1

package/index.d.ts

@@ -1,6 +1,618 @@
-export * from './create-entity-feature';
-export * from './model';
-export * from './local-store';
-export * from './trait-effect';
-export * from './util';
-export * from './cache';
+import * as i0 from '@angular/core';
+import { Type as Type$1, Injector, OnDestroy, InjectionToken } from '@angular/core';
+import * as _ngrx_store from '@ngrx/store';
+import { Store, ActionCreator, Action, Selector, SelectorWithProps, MemoizedSelector, ActionType, ReducerTypes } from '@ngrx/store';
+import { OnIdentifyEffects, OnRunEffects, Actions } from '@ngrx/effects';
+import { Observable } from 'rxjs';
+
+declare class TraitEffect implements OnIdentifyEffects, OnRunEffects {
+    private name;
+    componentId: string;
+    protected actions$: Actions<any>;
+    protected store: Store<any>;
+    ngrxOnIdentifyEffects(): string;
+    ngrxOnRunEffects(resolvedEffects$: Observable<any>): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TraitEffect, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TraitEffect>;
+}
+declare function getDestroyActionName(id: string): string;
+
+type TraitActions = {
+    [key: string]: ActionCreator<string, (...args: any[]) => Action<string>>;
+};
+type TraitSelectors<State> = {
+    [key: string]: Selector<State, any> | SelectorWithProps<State, any, any> | MemoizedSelector<State, any>;
+};
+type TraitStateMutators<State> = {
+    [key: string]: <S extends State>(...arg: any[]) => S;
+};
+interface BaseFeatureTraits<State = any, A = any, S = any> {
+    actions: A;
+    selectors: S;
+    reducer: (state: State, action: ActionType<any>) => State;
+    effects: Type$1<any>[];
+    initialState: State;
+}
+type FeatureTraits<State, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>> = BaseFeatureTraits<State, A, FeatureSelectors<State, S>>;
+type BaseEntityFeatureFactory<State, A, S> = (config: Config<State>) => BaseFeatureTraits<State, A, S>;
+type EntityFeatureFactory<EntityName extends string | undefined, EntitiesName extends string = `${EntityName}s`, State = any, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>> = (config: Config<State>) => FeatureTraits<State, EntityName extends string ? ReplaceEntityNames<A, EntityName, EntitiesName> : A, EntityName extends string ? ReplaceEntityNames<S, EntityName, EntitiesName> : S>;
+type Config<State, F extends MemoizedSelector<object, State> = MemoizedSelector<object, State>> = {
+    actionsGroupKey: string;
+    featureSelector: F | string;
+};
+type FeatureSelectors<State, S extends TraitSelectors<State>> = {
+    [key in keyof S]: MemoizedSelector<object, ReturnType<S[key]>, S[key]>;
+};
+type AllTraitConfigs = {
+    [id: string]: any;
+};
+type TraitActionsFactory<A extends TraitActions = TraitActions, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitActionsFactoryConfig<C>) => A;
+type TraitActionsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
+    actionsGroupKey: string;
+    entityName: string;
+    entitiesName: string;
+    allConfigs: C;
+};
+type TraitSelectorsFactory<State = unknown, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitSelectorsFactoryConfig<C>) => S;
+type TraitSelectorsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
+    previousSelectors: TraitSelectors<unknown> | undefined;
+    allConfigs: C;
+};
+type TraitInitialStateFactory<State = unknown, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitInitialStateFactoryConfig<C>) => State;
+type TraitInitialStateFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
+    previousInitialState: any;
+    allConfigs: C;
+};
+type TraitStateMutatorsFactory<State = unknown, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitStateMutatorsFactoryConfig<C>) => M;
+type TraitStateMutatorsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
+    allSelectors: TraitSelectors<any>;
+    previousMutators: TraitStateMutators<unknown> | undefined;
+    allConfigs: C;
+};
+type TraitReducerFactory<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitReducerFactoryConfig<State, A, S, M, C>) => (initialState: State, action: Action) => State;
+type TraitReducerFactoryConfig<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = {
+    initialState: State;
+    allActions: A;
+    allSelectors: S;
+    allMutators: M;
+    allConfigs: C;
+};
+type TraitEffectsFactory<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitEffectsFactoryConfig<State, A, S, C>) => Type$1<TraitEffect>[];
+type TraitEffectsFactoryConfig<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = {
+    allActions: A;
+    allSelectors: S;
+    allConfigs: C;
+};
+type KeyedConfig<KEY extends string, C> = Record<string, any> & {
+    [K in KEY]?: C;
+};
+interface TraitFactory<State = any, A extends TraitActions = any, S extends TraitSelectors<State> = any, M extends TraitStateMutators<State> = any, KEY extends string = string, C = any, KC extends AllTraitConfigs = KeyedConfig<KEY, C>> {
+    key: KEY;
+    config?: C;
+    depends?: string[];
+    actions: TraitActionsFactory<A, KC>;
+    selectors: TraitSelectorsFactory<State, S, KC>;
+    initialState: TraitInitialStateFactory<State, KC>;
+    mutators: TraitStateMutatorsFactory<State, M, KC>;
+    reducer?: TraitReducerFactory<State, A, S, M, KC>;
+    effects?: TraitEffectsFactory<State, A, S, KC>;
+}
+type ExtractArrayElementTypes<X> = X extends ReadonlyArray<infer T> ? T : never;
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+type ExtractStateType<T> = T extends TraitFactory<infer State> ? State : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractStateType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<infer State> ? State : never;
+type ExtractActionsType<T> = T extends TraitFactory<any, infer A> ? A : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractActionsType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<any, infer A> ? A : never;
+type ExtractSelectorsType<T> = T extends TraitFactory<any, any, infer S> ? S : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractSelectorsType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<any, any, infer S> ? S : never;
+type ExtractMutatorsType<T> = T extends TraitFactory<any, any, any, infer M> ? M : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractMutatorsType<ExtractArrayElementTypes<T>>> : never;
+type ExtractKeyedConfigType<T> = T extends TraitFactory<any, any, any, any, infer KEY, infer C> ? KeyedConfig<KEY, C> : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractKeyedConfigType<ExtractArrayElementTypes<T>>> : never;
+type PrefixProps<T, P extends string> = {
+    [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K];
+};
+type PostfixProps<T, P extends string> = {
+    [K in keyof T as `${Uncapitalize<string & K>}${Capitalize<P>}`]: T[K];
+};
+type Replace<Target extends string, FindKey extends string, FindKey2 extends string, ReplaceKey extends string, ReplaceKey2 extends string> = Target extends `${infer Prefix}${FindKey}${infer Postfix}` ? `${Prefix}${Capitalize<ReplaceKey>}${Postfix}` : Target extends `${infer Prefix}${FindKey2}${infer Postfix}` ? `${Prefix}${Capitalize<ReplaceKey2>}${Postfix}` : Target;
+type ReplaceProps<Target, FindKey extends string, FindKey2 extends string, ReplaceKey extends string, ReplaceKey2 extends string> = {
+    [Prop in keyof Target as Replace<string & Prop, FindKey, FindKey2, ReplaceKey, ReplaceKey2>]: Target[Prop];
+};
+type ReplaceEntityNames<T, EntityName extends string, EntitiesName extends string> = ReplaceProps<T, 'Entities', 'Entity', EntitiesName, EntityName>;
+
+/**
+ * Builds traitFactory and registers effects and reducers with
+ * a generated component id, returns build actions and selectors
+ * and a destroy method that will unergister the effects and reducers
+ * when called, and a addEffect which can be use to register extra effects
+ *
+ * Used inside TraitsLocalStore, can be used to create your
+ * own Component Service without extending TraitsLocalStore
+ * @param injector
+ * @param componentName
+ * @param traitFactory
+ */
+declare function buildLocalTraits<State, F extends BaseEntityFeatureFactory<any, any, any>>(injector: Injector, componentName: string, traitFactory: F): {
+    destroy: () => void;
+    actions: any;
+    selectors: any;
+    addEffects(localEffect: TraitEffect): void;
+};
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+interface LocalTraitsConfig<F extends BaseEntityFeatureFactory<any, any, any>> {
+    componentName: string;
+    traitsFactory: F;
+}
+/**
+ * Class used to create local traits service, receives a trait factory, which will be
+ * built and its reducers and effect register using a dynamic id when the service is built
+ * and get destroyed when the onDestroy lifecycle method of the service is called, if the service
+ * has effects this.traits.addEffects(this) should be call in the constructor
+ *
+ * @example
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ * );
+ *
+ * Injectable()
+ * export class ProductsLocalTraits extends TraitsLocalStore<
+ *   typeof productFeatureFactory
+ * > {
+ *   loadProducts$ = createEffect(() =>
+ *     this.actions$.pipe(
+ *       ofType(this.localActions.loadProducts),
+ *       switchMap(() =>
+ *         //call your service to get the products data
+ *         this.productService.getProducts().pipe(
+ *           map((res) =>
+ *             this.localActions.loadProductsSuccess({ entities: res.resultList })
+ *           ),
+ *           catchError(() => of(this.localActions.loadProductsFail()))
+ *         )
+ *       )
+ *     )
+ *   );
+ *
+ *   constructor(injector: Injector, private productService: ProductService) {
+ *     super(injector);
+ *     this.traits.addEffects(this); // IMPORTANT! add this line if the service has effects
+ *   }
+ *
+ *   setup(): LocalTraitsConfig<typeof productFeatureFactory> {
+ *     return {
+ *       componentName: 'ProductsPickerComponent',
+ *       traitsFactory: productFeatureFactory,
+ *     };
+ *   }
+ * }
+ *
+ * // use in component later
+ *
+ * Component({
+ *   selector: 'some-component',
+ *   template: `<div> some content</div> `,
+ *   providers: [ProductsLocalTraits],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class ProductSelectDialogComponent implements OnInit {
+ *   constructor(private store: Store, private traits: ProductsLocalTraits) {}
+ *
+ *   ngOnInit() {
+ *     this.store.dispatch(this.traits.localActions.loadProducts());
+ *   }
+ * }
+ */
+declare abstract class TraitsLocalStore<F extends BaseEntityFeatureFactory<any, any, any>> extends TraitEffect implements OnDestroy {
+    traits: {
+        actions: ReturnType<F>['actions'];
+        selectors: ReturnType<F>['selectors'];
+        destroy: () => void;
+        addEffects: (localEffect: TraitEffect) => void;
+    };
+    localActions: ReturnType<F>['actions'];
+    localSelectors: ReturnType<F>['selectors'];
+    private injector;
+    constructor();
+    abstract setup(): LocalTraitsConfig<F>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TraitsLocalStore<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TraitsLocalStore<any>>;
+}
+
+/**
+ * @ignore
+ * @internal
+ */
+declare const DISABLE_LOCAL_TRAIT_EFFECTS: InjectionToken<boolean>;
+
+/**
+ * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
+ * which combines all the traits actions, selectors , reducers and effects,
+ * the names param will replace any action and selector with the word Entity or Entities,
+ * with the corresponding entityName and  entitiesName param (entityName+'s' if entitiesName is omitted).
+ * @param namesConfig - Optional Names for entities
+ * @param namesConfig.entityName - singular name for entity
+ * @param [namesConfig.entitiesName] - plural name for entities, defaults to entityName + 's'
+ * @param traits set of traits to be combined
+ *
+ * @example
+ *
+ * const featureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ *   addAsyncActionTrait({
+ *     name: 'checkout',
+ *     actionSuccessProps: props<{ orderId: string }>(),
+ *   })
+ * );
+ *
+ * export const productsFeature = featureFactory({
+ *   actionsGroupKey: '[Products]',
+ *   featureSelector: 'products',
+ * });
+ */
+declare function createEntityFeatureFactory<F extends readonly TraitFactory[], EntityName extends string, EntitiesName extends string = `${EntityName}s`>({ entityName, entitiesName, }: {
+    entityName: EntityName;
+    entitiesName?: EntitiesName;
+}, ...traits: F): EntityFeatureFactory<EntityName, EntitiesName, ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
+/**
+ * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
+ * which combines all the traits actions, selectors , reducers and effects.
+ * @param traits set of traits to be combined
+ *
+ * @example
+ *
+ * const featureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ *   addAsyncActionTrait({
+ *     name: 'checkout',
+ *     actionSuccessProps: props<{ orderId: string }>(),
+ *   })
+ * );
+ *
+ * export const productsFeature = featureFactory({
+ *   actionsGroupKey: '[Products]',
+ *   featureSelector: 'products',
+ * });
+ *
+ * productsFeature.actions.loadProducts();
+ */
+declare function createEntityFeatureFactory<F extends readonly TraitFactory[]>(...traits: F): EntityFeatureFactory<'Entity', 'Entities', ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
+/**
+ * Combine a map entityFeatureFactories into one,
+ * grouping the actions and selectors by the key of the respective entityFeatureFactory
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productCombinedFactory = combineEntityFeatures({
+ *   products: productFeatureFactory,
+ *   productOrders: productOrderFeatureFactory,
+ *   clients: clientsFeatureFactory,
+ * });
+ *
+ * const combinedFeature = productCombinedFactory({
+ *     actionsGroupKey: '[Combined]',
+ *     featureSelector: 'combined',
+ *   });
+ *
+ *   combinedFeature.actions.client.loadClients();
+ *   combinedFeature.actions.product.loadProducts();
+ */
+declare function combineEntityFeatures<T extends {
+    [key: string]: EntityFeatureFactory<any, any>;
+}, K extends keyof T, State extends {
+    [P in K]: ExtractStateType<ReturnType<T[P]>>;
+}, A extends {
+    [P in K]: ExtractActionsType<ReturnType<T[P]>>;
+}, S extends {
+    [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;
+}, R extends (config: Config<State>) => {
+    actions: A;
+    selectors: S;
+    reducer: (state: State, action: ActionType<any>) => State;
+    effects: Type<any>[];
+    initialState: State;
+}>(traitFactoriesMap: T): R;
+/**
+ * Mix a map entityFeatureFactories into one, different from combine the actions and selectors a mix, not group by key like in combine, the keys are still use
+ * internal in the reducers and selector to separate the state
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productMixedFactory = mixEntityFeatures({
+ *   products: productFeatureFactory,
+ *   productOrders: productOrderFeatureFactory,
+ *   clients: clientsFeatureFactory,
+ * });
+ *
+ * const mixedFeature = productMixedFactory({
+ *     actionsGroupKey: '[Mixed]',
+ *     featureSelector: 'mixed',
+ *   });
+ * mixedFeature.actions.loadClients();
+ * mixedFeature.actions.loadProducts();
+ *
+ */
+declare function mixEntityFeatures<T extends {
+    [key: string]: EntityFeatureFactory<any, any>;
+}, K extends keyof T, State extends {
+    [P in K]: ExtractStateType<ReturnType<T[P]>>;
+}, A extends TraitActions & UnionToIntersection<ExtractActionsType<ReturnType<T[K]>>>, S extends TraitSelectors<any> & UnionToIntersection<FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[K]>>>>, R extends EntityFeatureFactory<any, any, State, A, S>>(traitFactoriesMap: T): R;
+/**
+ * Combines targetTraitFactory with the traitFactoriesMap using the keys as props for the targetTraitFactory state,
+ * and grouping the combined actions by key
+ * @param targetTraitFactory
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productAddEntityPropertiesFactory = addEntityFeaturesProperties(
+ *   productFeatureFactory,
+ *   {
+ *     productOrders: productOrderFeatureFactory,
+ *     clients: clientsFeatureFactory,
+ *   }
+ * );
+ *
+ * const combinedFeature = productAddEntityPropertiesFactory({
+ *     actionsGroupKey: '[addEntityFeatures]',
+ *     featureSelector: 'addEntityFeatures',
+ *   });
+ *
+ *   combinedFeature.actions.loadProducts();
+ *   combinedFeature.actions.clients.loadClients();
+ *   combinedFeature.actions.productOrders.loadProductOrders();
+ */
+declare function addEntityFeaturesProperties<F extends EntityFeatureFactory<any, any>, T extends {
+    [key: string]: EntityFeatureFactory<any, any, any, any, any>;
+}, K extends keyof T, State extends ExtractStateType<ReturnType<F>> & {
+    [P in K]: ExtractStateType<ReturnType<T[P]>>;
+}, A extends ExtractActionsType<ReturnType<F>> & {
+    [P in K]: ExtractActionsType<ReturnType<T[P]>>;
+}, S extends FeatureSelectors<State, ExtractSelectorsType<ReturnType<F>>> & {
+    [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;
+}, R extends (config: Config<State>) => {
+    actions: A;
+    selectors: S;
+    reducer: (state: State, action: ActionType<any>) => State;
+    effects: Type<any>[];
+    initialState: State;
+}>(targetTraitFactory: F, traitFactoriesMap: T): R;
+/**
+ * Helper function to create an implementation  a TraitFactory
+ * @param f TraitFactory implementation
+ */
+declare function createTraitFactory<State = {}, A extends TraitActions = {}, S extends TraitSelectors<State> = {}, M extends TraitStateMutators<State> = {}, KEY extends string = string, C = unknown, KC extends AllTraitConfigs = KeyedConfig<KEY, C>>(f: {
+    key: KEY;
+    config?: C;
+    depends?: string[];
+    actions?: TraitActionsFactory<A, KC>;
+    selectors?: TraitSelectorsFactory<State, S, KC>;
+    initialState?: TraitInitialStateFactory<State, KC>;
+    mutators?: TraitStateMutatorsFactory<State, M, KC>;
+    reducer?: TraitReducerFactory<State, A, S, M, KC>;
+    effects?: TraitEffectsFactory<State, A, S, KC>;
+}): TraitFactory<State, A, S, M, KEY, C, KC>;
+/**
+ * Helper function to combine selectors in components as map
+ *
+ * @example
+ *
+ * view = combineSelectors({
+ *     products: ProductSelectors.selectProductsCurrentPage,
+ *     isLoading: ProductSelectors.isLoadingProductsCurrentPage,
+ *     selectedProduct: ProductSelectors.selectProductSelected,
+ *     isLoadingCheckout: ProductSelectors.isLoadingCheckout,
+ *     selectedSort: ProductSelectors.selectProductsSort,
+ *     filters: ProductSelectors.selectProductsFilter,
+ *   });
+ * @param t
+ */
+declare function combineSelectors<T extends {
+    [k: string]: MemoizedSelector<any, any>;
+}>(t: T): MemoizedSelector<any, {
+    [j in keyof T]: ReturnType<T[j]>;
+}>;
+
+declare function insertIf<State>(condition: any, getElement: () => ReducerTypes<State, ActionCreator[]>): ReducerTypes<State, ActionCreator[]>[];
+declare function toMap(a: Array<string | number>): {
+    [key: string]: boolean;
+};
+declare function capitalize(name: string): string;
+declare function camelCaseToSentence(text: string): string;
+/**
+ * Set propertyReducer in sourceReducer in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer, 'selectedProduct', selectedProductReducer)
+ */
+declare function setPropertyReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, property: P, propertyReducer: (state: State[P], action: ActionType<any>) => State[P]): (state: State, action: ActionType<any>) => State;
+/**
+ * Set propertyReducers in sourceReducer each in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer,
+ * {
+ *    selectedProduct: selectedProductReducer
+ *    favoriteProduct: favoriteProductReducer
+ * })
+ */
+declare function setPropertiesReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, propertiesReducers: {
+    [key in P]: (state: State[P], action: ActionType<any>) => State[P];
+}): (state: State, action: ActionType<any>) => State;
+/**
+ * joins two reducers so the work in the same state
+ * @param firstReducer
+ * @param secondReducer
+ */
+declare function joinReducers<State>(firstReducer: (state: State, action: ActionType<any>) => State, secondReducer: (state: any, action: ActionType<any>) => any): (state: State, action: ActionType<any>) => State;
+
+type CacheKey = string | (string | object)[];
+interface CacheData {
+    value: any;
+    date: number;
+    invalid: boolean;
+    hitCount: number;
+}
+interface CacheKeys {
+    keys?: {
+        [key: string]: CacheKeys;
+    };
+    data?: CacheData;
+}
+
+/**
+ * Cache the result of source parameter using the provided key, when call
+ * again if the cache is valid (exist and is not expired or invalidated)
+ * it will return the cache value without calling again source
+ * @example
+ * // cache for 3 min
+ * loadStores$ = createEffect(() => {
+ *   return this.actions$.pipe(
+ *     ofType(ProductStoreActions.loadStores),
+ *     exhaustMap(() =>
+ *       cache({
+ *         key: ['stores'],
+ *         store: this.store,
+ *         source: this.storeService.getStores(),
+ *         expire: 1000 * 60 * 3 // optional param , cache forever if not present
+ *       }).pipe(
+ *         map((res) => ProductStoreActions.loadStoresSuccess({ entities: res })),
+ *         catchError(() => of(ProductStoreActions.loadStoresFail()))
+ *       )
+ *     )
+ *   );
+ * });
+ * // cache top 10, for 3 mins
+ *   loadDepartments$ = createEffect(() => {
+ *   return this.actions$.pipe(
+ *     ofType(this.localActions.loadDepartments),
+ *     concatLatestFrom(() =>
+ *       this.store.select(this.localSelectors.selectDepartmentsFilter)
+ *     ),
+ *     exhaustMap(([_, filters]) =>
+ *       cache({
+ *         key: ['stores','departments',{ storeId: filters!.storeId },
+ *         store: this.store,
+ *         source: this.storeService.getStoreDepartments(filters!.storeId),
+ *         expires: 1000 * 60 * 3,
+ *         maxCacheSize: 10,
+ *       }).pipe(
+ *         map((res) =>
+ *           this.localActions.loadDepartmentsSuccess({
+ *             entities: res,
+ *           })
+ *         ),
+ *         catchError(() => of(this.localActions.loadDepartmentsFail()))
+ *       )
+ *     )
+ *   );
+ * });
+ *
+ * @param options - configuration
+ * @param options.store - required ngrx store
+ * @param options.key - key can be string, array of string or array of string with plain objects
+ * @param options.source - called when cache is invalid
+ * @param options.expires - time to expire the cache valued, if not present is infinite
+ * @param options.maxCacheSize - max number of keys to store , only works if last key is variable
+ */
+declare function cache<T>({ store, key, source, expires, maxCacheSize, skip, }: {
+    store: Store;
+    key: CacheKey;
+    source: Observable<T>;
+    expires?: number;
+    maxCacheSize?: number;
+    skip?: boolean;
+}): Observable<any>;
+
+declare class CacheModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CacheModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CacheModule>;
+}
+
+declare const CacheActions: {
+    invalidateCache: _ngrx_store.ActionCreator<"[Cache] Invalidate Cache", (props: {
+        key: CacheKey;
+    }) => {
+        key: CacheKey;
+    } & _ngrx_store.Action<"[Cache] Invalidate Cache">>;
+    deleteCache: _ngrx_store.ActionCreator<"[Cache] Delete Cache", (props: {
+        key: CacheKey;
+    }) => {
+        key: CacheKey;
+    } & _ngrx_store.Action<"[Cache] Delete Cache">>;
+};
+declare const CacheSelectors: {
+    getCache: (key: CacheKey) => _ngrx_store.MemoizedSelector<object, CacheData | undefined, (s1: CacheKeys) => CacheData | undefined>;
+};
+
+export { CacheActions, CacheModule, CacheSelectors, DISABLE_LOCAL_TRAIT_EFFECTS, TraitEffect, TraitsLocalStore, addEntityFeaturesProperties, buildLocalTraits, cache, camelCaseToSentence, capitalize, combineEntityFeatures, combineSelectors, createEntityFeatureFactory, createTraitFactory, getDestroyActionName, insertIf, joinReducers, mixEntityFeatures, setPropertiesReducer, setPropertyReducer, toMap };
+export type { AllTraitConfigs, BaseEntityFeatureFactory, BaseFeatureTraits, Config, EntityFeatureFactory, ExtractActionsType, ExtractKeyedConfigType, ExtractMutatorsType, ExtractSelectorsType, ExtractStateType, FeatureSelectors, FeatureTraits, KeyedConfig, LocalTraitsConfig, PostfixProps, PrefixProps, ReplaceEntityNames, ReplaceProps, TraitActions, TraitActionsFactory, TraitActionsFactoryConfig, TraitEffectsFactory, TraitEffectsFactoryConfig, TraitFactory, TraitInitialStateFactory, TraitInitialStateFactoryConfig, TraitReducerFactory, TraitReducerFactoryConfig, TraitSelectors, TraitSelectorsFactory, TraitSelectorsFactoryConfig, TraitStateMutators, TraitStateMutatorsFactory, TraitStateMutatorsFactoryConfig, Type, UnionToIntersection };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "./node_modules/ng-packagr/package.schema.json",
   "name": "@ngrx-traits/core",
-  "version": "19.2.2",
+  "version": "20.0.0-beta.1",
   "license": "MIT",
   "peerDependencies": {
     "@angular/core": "^19.0.0",

package/testing/index.d.ts

@@ -1 +1,11 @@
-export * from './provide-mock-local-traits';
+import { TraitsLocalStore, EntityFeatureFactory } from '@ngrx-traits/core';
+import { Type, Provider } from '@angular/core';
+
+declare function provideMockLocalTraits<T extends TraitsLocalStore<EntityFeatureFactory<any, any>>>({ traitFactory, selectors, }: {
+    traitFactory: Type<T>;
+    selectors?: {
+        [key in keyof T['localSelectors']]?: ReturnType<T['localSelectors'][key]>;
+    };
+}): Provider[];
+
+export { provideMockLocalTraits };

package/cache/cache.actions.d.ts

@@ -1,29 +0,0 @@
-import { CacheKey } from './cache.models';
-export declare const cache: import("@ngrx/store").ActionCreator<"[Cache] Cache", (props: {
-    key: CacheKey;
-    value: any;
-    date: number;
-    maxCacheSize?: number;
-    expires?: number;
-}) => {
-    key: CacheKey;
-    value: any;
-    date: number;
-    maxCacheSize?: number;
-    expires?: number;
-} & import("@ngrx/store").Action<"[Cache] Cache">>;
-export declare const hitCache: import("@ngrx/store").ActionCreator<"[Cache] Hit Cache", (props: {
-    key: CacheKey;
-}) => {
-    key: CacheKey;
-} & import("@ngrx/store").Action<"[Cache] Hit Cache">>;
-export declare const invalidateCache: import("@ngrx/store").ActionCreator<"[Cache] Invalidate Cache", (props: {
-    key: CacheKey;
-}) => {
-    key: CacheKey;
-} & import("@ngrx/store").Action<"[Cache] Invalidate Cache">>;
-export declare const deleteCache: import("@ngrx/store").ActionCreator<"[Cache] Delete Cache", (props: {
-    key: CacheKey;
-}) => {
-    key: CacheKey;
-} & import("@ngrx/store").Action<"[Cache] Delete Cache">>;