@ngrx-traits/core 12.1.2 → 13.0.0-beta.2

package/esm2020/local-store/traits-local-store.mjs

@@ -0,0 +1,147 @@
+import { Injectable, Injector } from '@angular/core';
+import { createFeatureSelector, ReducerManager, Store } from '@ngrx/store';
+import { Actions, EffectSources } from '@ngrx/effects';
+import { getDestroyActionName, TraitEffect } from '../trait-effect';
+import { DISABLE_LOCAL_TRAIT_EFFECTS } from './disable-local-trait-effects.token';
+import * as i0 from "@angular/core";
+let id = 0;
+function uniqueComponentId() {
+    return id++;
+}
+/**
+ * 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
+ */
+export function buildLocalTraits(injector, componentName, traitFactory) {
+    const reducers = injector.get(ReducerManager);
+    const effects = injector.get(EffectSources);
+    const store = injector.get(Store);
+    const componentId = `${componentName}_${uniqueComponentId()}`;
+    const traits = traitFactory({
+        featureSelector: createFeatureSelector(componentId),
+        actionsGroupKey: `[${componentId}]`,
+    });
+    traits.reducer && reducers.addReducer(componentId, traits.reducer);
+    const providers = (traits.effects && [...traits.effects.map((e) => ({ provide: e }))]) || [];
+    const disableLocalTraitsEffects = injector.get(DISABLE_LOCAL_TRAIT_EFFECTS, false);
+    if (!disableLocalTraitsEffects) {
+        const i = Injector.create({
+            providers: providers,
+            parent: injector,
+        });
+        traits.effects?.forEach((e) => {
+            const effect = i.get(e);
+            effect.componentId = componentId;
+            effects.addEffects(effect);
+        });
+    }
+    function destroy() {
+        store.dispatch({ type: getDestroyActionName(componentId) });
+        /**
+         * A service that extends TraitsLocalStore and other component service are destroyed
+         * before the component that depends on them, this causes that any subscriptions
+         * to selectors of the TraitsLocalStore could fail because the store state is removed before
+         * they are unsubscribe by the onDestroy of the component. Executing reducers.removeReducer
+         * inside setTimeout ensures the state is remove after the component onDestroy was called,
+         * avoiding the before mentioned possible issues.
+         */
+        setTimeout(() => reducers.removeReducer(componentId));
+    }
+    return {
+        destroy,
+        actions: traits.actions,
+        selectors: traits.selectors,
+        addEffects(localEffect) {
+            localEffect.componentId = componentId;
+            effects.addEffects(localEffect);
+        },
+    };
+}
+/**
+ * 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());
+ *   }
+ * }
+ */
+export class TraitsLocalStore extends TraitEffect {
+    constructor(injector) {
+        super(injector.get(Actions), injector.get(Store));
+        this.injector = injector;
+        const config = this.setup();
+        this.traits = buildLocalTraits(this.injector, config.componentName, config.traitsFactory);
+        this.localActions = this.traits.actions;
+        this.localSelectors = this.traits.selectors;
+    }
+    ngOnDestroy() {
+        this.traits.destroy();
+    }
+}
+TraitsLocalStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"traits-local-store.js","sourceRoot":"","sources":["../../../../../../libs/ngrx-traits/core/src/lib/local-store/traits-local-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, OnDestroy } from '@angular/core';\nimport { BaseEntityFeatureFactory, EntityFeatureFactory } from '../model';\nimport { createFeatureSelector, ReducerManager, Store } from '@ngrx/store';\nimport { Actions, EffectSources } from '@ngrx/effects';\nimport { getDestroyActionName, TraitEffect } from '../trait-effect';\nimport { DISABLE_LOCAL_TRAIT_EFFECTS } from './disable-local-trait-effects.token';\n\nlet id = 0;\nfunction uniqueComponentId() {\n  return id++;\n}\n\n/**\n * Builds traitFactory and registers effects and reducers with\n * a generated component id, returns build actions and selectors\n * and a destroy method that will unergister the effects and reducers\n * when called, and a addEffect which can be use to register extra effects\n *\n * Used inside TraitsLocalStore, can be used to create your\n * own Component Service without extending TraitsLocalStore\n * @param injector\n * @param componentName\n * @param traitFactory\n */\nexport function buildLocalTraits<\n  State,\n  F extends BaseEntityFeatureFactory<any, any, any>\n>(injector: Injector, componentName: string, traitFactory: F) {\n  const reducers = injector.get(ReducerManager);\n  const effects = injector.get(EffectSources);\n  const store = injector.get(Store);\n  const componentId = `${componentName}_${uniqueComponentId()}`;\n\n  const traits = traitFactory({\n    featureSelector: createFeatureSelector<State>(componentId),\n    actionsGroupKey: `[${componentId}]`,\n  }) as ReturnType<F>;\n\n  traits.reducer && reducers.addReducer(componentId, traits.reducer);\n\n  const providers =\n    (traits.effects && [...traits.effects.map((e) => ({ provide: e }))]) || [];\n\n  const disableLocalTraitsEffects = injector.get(\n    DISABLE_LOCAL_TRAIT_EFFECTS,\n    false\n  );\n  if (!disableLocalTraitsEffects) {\n    const i = Injector.create({\n      providers: providers,\n      parent: injector,\n    });\n\n    traits.effects?.forEach((e) => {\n      const effect = i.get(e) as TraitEffect;\n      effect.componentId = componentId;\n      effects.addEffects(effect);\n    });\n  }\n\n  function destroy() {\n    store.dispatch({ type: getDestroyActionName(componentId) });\n    /**\n     * A service that extends TraitsLocalStore and other component service are destroyed\n     * before the component that depends on them, this causes that any subscriptions\n     * to selectors of the TraitsLocalStore could fail because the store state is removed before\n     * they are unsubscribe by the onDestroy of the component. Executing reducers.removeReducer\n     * inside setTimeout ensures the state is remove after the component onDestroy was called,\n     * avoiding the before mentioned possible issues.\n     */\n    setTimeout(() => reducers.removeReducer(componentId));\n  }\n\n  return {\n    destroy,\n    actions: traits.actions,\n    selectors: traits.selectors,\n    addEffects(localEffect: TraitEffect) {\n      localEffect.componentId = componentId;\n      effects.addEffects(localEffect);\n    },\n  };\n}\n\nexport interface Type<T> extends Function {\n  new (...args: any[]): T;\n}\n\nexport interface LocalTraitsConfig<\n  F extends BaseEntityFeatureFactory<any, any, any>\n> {\n  componentName: string;\n  traitsFactory: F;\n}\n\n/**\n * Class used to create local traits service, receives a trait factory, which will be\n * built and its reducers and effect register using a dynamic id when the service is built\n * and get destroyed when the onDestroy lifecycle method of the service is called, if the service\n * has effects this.traits.addEffects(this) should be call in the constructor\n *\n * @example\n * const productFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntityTrait<Product>(),\n * );\n *\n * Injectable()\n * export class ProductsLocalTraits extends TraitsLocalStore<\n *   typeof productFeatureFactory\n * > {\n *   loadProducts$ = createEffect(() =>\n *     this.actions$.pipe(\n *       ofType(this.localActions.loadProducts),\n *       switchMap(() =>\n *         //call your service to get the products data\n *         this.productService.getProducts().pipe(\n *           map((res) =>\n *             this.localActions.loadProductsSuccess({ entities: res.resultList })\n *           ),\n *           catchError(() => of(this.localActions.loadProductsFail()))\n *         )\n *       )\n *     )\n *   );\n *\n *   constructor(injector: Injector, private productService: ProductService) {\n *     super(injector);\n *     this.traits.addEffects(this); // IMPORTANT! add this line if the service has effects\n *   }\n *\n *   setup(): LocalTraitsConfig<typeof productFeatureFactory> {\n *     return {\n *       componentName: 'ProductsPickerComponent',\n *       traitsFactory: productFeatureFactory,\n *     };\n *   }\n * }\n *\n * // use in component later\n *\n * Component({\n *   selector: 'some-component',\n *   template: `<div> some content</div> `,\n *   providers: [ProductsLocalTraits],\n *   changeDetection: ChangeDetectionStrategy.OnPush,\n * })\n * export class ProductSelectDialogComponent implements OnInit {\n *   constructor(private store: Store, private traits: ProductsLocalTraits) {}\n *\n *   ngOnInit() {\n *     this.store.dispatch(this.traits.localActions.loadProducts());\n *   }\n * }\n */\n@Injectable()\nexport abstract class TraitsLocalStore<\n    F extends BaseEntityFeatureFactory<any, any, any>\n  >\n  extends TraitEffect\n  implements OnDestroy\n{\n  traits: {\n    actions: ReturnType<F>['actions'];\n    selectors: ReturnType<F>['selectors'];\n    destroy: () => void;\n    addEffects: (localEffect: TraitEffect) => void;\n  };\n\n  localActions: ReturnType<F>['actions'];\n  localSelectors: ReturnType<F>['selectors'];\n\n  public constructor(public injector: Injector) {\n    super(injector.get(Actions), injector.get(Store));\n    const config = this.setup();\n    this.traits = buildLocalTraits(\n      this.injector,\n      config.componentName,\n      config.traitsFactory\n    );\n    this.localActions = this.traits.actions;\n    this.localSelectors = this.traits.selectors;\n  }\n\n  abstract setup(): LocalTraitsConfig<F>;\n\n  ngOnDestroy() {\n    this.traits.destroy();\n  }\n}\n"]}

package/esm2020/model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../../../libs/ngrx-traits/core/src/lib/model.ts"],"names":[],"mappings":"","sourcesContent":["/* eslint-disable @typescript-eslint/consistent-type-definitions */\nimport {\n  ActionCreator,\n  Selector,\n  SelectorWithProps,\n  TypedAction,\n} from '@ngrx/store/src/models';\nimport { Action, ActionType, MemoizedSelector } from '@ngrx/store';\nimport { Type } from '@angular/core';\nimport { TraitEffect } from './trait-effect';\n\nexport type TraitActions = {\n  [key: string]: ActionCreator<string, (...args: any[]) => TypedAction<string>>;\n};\n\nexport type TraitSelectors<State> = {\n  [key: string]:\n    | Selector<State, any>\n    | SelectorWithProps<State, any, any>\n    | MemoizedSelector<State, any>;\n};\n\nexport type TraitStateMutators<State> = {\n  [key: string]: <S extends State>(...arg: any[]) => S;\n};\n\nexport interface BaseFeatureTraits<State = any, A = any, S = any> {\n  actions: A;\n  selectors: S;\n  reducer: (state: State, action: ActionType<any>) => State;\n  effects: Type<any>[];\n  initialState: State;\n}\n\nexport type FeatureTraits<\n  State,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>\n> = BaseFeatureTraits<State, A, FeatureSelectors<State, S>>;\n\nexport type BaseEntityFeatureFactory<State, A, S> = (\n  config: Config<State>\n) => BaseFeatureTraits<State, A, S>;\n\nexport type EntityFeatureFactory<\n  EntityName extends string | undefined,\n  EntitiesName extends string = `${EntityName}s`,\n  State = any,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>\n> = (\n  config: Config<State>\n) => FeatureTraits<\n  State,\n  EntityName extends string\n    ? ReplaceEntityNames<A, EntityName, EntitiesName>\n    : A,\n  EntityName extends string\n    ? ReplaceEntityNames<S, EntityName, EntitiesName>\n    : S\n>;\n\nexport type Config<\n  State,\n  F extends MemoizedSelector<object, State> = MemoizedSelector<object, State>\n> = {\n  actionsGroupKey: string;\n  featureSelector: F | string;\n};\n\nexport type FeatureSelectors<State, S extends TraitSelectors<State>> = {\n  [key in keyof S]: MemoizedSelector<object, ReturnType<S[key]>, S[key]>;\n};\n\n// TODO see if we can make AllTraitConfigs extends or use KeyedConfig\nexport type AllTraitConfigs = {\n  [id: string]: any;\n};\n\nexport type TraitActionsFactory<\n  A extends TraitActions = TraitActions,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (options: TraitActionsFactoryConfig<C>) => A;\n\nexport type TraitActionsFactoryConfig<\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  actionsGroupKey: string;\n  entityName: string;\n  entitiesName: string;\n  allConfigs: C;\n};\nexport type TraitSelectorsFactory<\n  State = unknown,\n  S extends TraitSelectors<State> = TraitSelectors<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (options: TraitSelectorsFactoryConfig<C>) => S;\n\nexport type TraitSelectorsFactoryConfig<\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  previousSelectors: TraitSelectors<unknown> | undefined;\n  allConfigs: C;\n};\nexport type TraitInitialStateFactory<\n  State = unknown,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (options: TraitInitialStateFactoryConfig<C>) => State;\n\nexport type TraitInitialStateFactoryConfig<\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  previousInitialState: any;\n  allConfigs: C;\n};\n\nexport type TraitStateMutatorsFactory<\n  State = unknown,\n  M extends TraitStateMutators<State> = TraitStateMutators<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (options: TraitStateMutatorsFactoryConfig<C>) => M;\n\nexport type TraitStateMutatorsFactoryConfig<\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  allSelectors: TraitSelectors<any>;\n  previousMutators: TraitStateMutators<unknown> | undefined;\n  allConfigs: C;\n};\n\nexport type TraitReducerFactory<\n  State = unknown,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>,\n  M extends TraitStateMutators<State> = TraitStateMutators<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (\n  options: TraitReducerFactoryConfig<State, A, S, M, C>\n) => (initialState: State, action: Action) => State;\n\nexport type TraitReducerFactoryConfig<\n  State = unknown,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>,\n  M extends TraitStateMutators<State> = TraitStateMutators<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  initialState: State;\n  allActions: A;\n  allSelectors: S;\n  allMutators: M;\n  allConfigs: C;\n};\n\nexport type TraitEffectsFactory<\n  State = unknown,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = (options: TraitEffectsFactoryConfig<State, A, S, C>) => Type<TraitEffect>[];\n\nexport type TraitEffectsFactoryConfig<\n  State = unknown,\n  A extends TraitActions = TraitActions,\n  S extends TraitSelectors<State> = TraitSelectors<State>,\n  C extends AllTraitConfigs = AllTraitConfigs\n> = {\n  allActions: A;\n  allSelectors: S;\n  allConfigs: C;\n};\n\nexport type KeyedConfig<KEY extends string, C> = Record<string, any> &\n  {\n    [K in KEY]?: C;\n  };\n\nexport interface TraitFactory<\n  State = any,\n  A extends TraitActions = any,\n  S extends TraitSelectors<State> = any,\n  M extends TraitStateMutators<State> = any,\n  KEY extends string = string,\n  C = any,\n  KC = KeyedConfig<KEY, C>\n> {\n  key: KEY;\n  config?: C;\n  depends?: string[];\n  actions: TraitActionsFactory<A, KC>;\n  selectors: TraitSelectorsFactory<State, S, KC>;\n  initialState: TraitInitialStateFactory<State, KC>;\n  mutators: TraitStateMutatorsFactory<State, M, KC>;\n  reducer?: TraitReducerFactory<State, A, S, M, KC>;\n  effects?: TraitEffectsFactory<State, A, S, KC>;\n}\ntype ExtractArrayElementTypes<X> = X extends ReadonlyArray<infer T> ? T : never;\n\nexport type UnionToIntersection<T> = (\n  T extends any ? (x: T) => any : never\n) extends (x: infer R) => any\n  ? R\n  : never;\n\nexport type ExtractStateType<T> = T extends TraitFactory<infer State>\n  ? State\n  : T extends ReadonlyArray<TraitFactory>\n  ? UnionToIntersection<ExtractStateType<ExtractArrayElementTypes<T>>>\n  : T extends BaseFeatureTraits<infer State>\n  ? State\n  : never;\n\nexport type ExtractActionsType<T> = T extends TraitFactory<any, infer A>\n  ? A\n  : T extends ReadonlyArray<TraitFactory>\n  ? UnionToIntersection<ExtractActionsType<ExtractArrayElementTypes<T>>>\n  : T extends BaseFeatureTraits<any, infer A>\n  ? A\n  : never;\n\nexport type ExtractSelectorsType<T> = T extends TraitFactory<any, any, infer S>\n  ? S\n  : T extends ReadonlyArray<TraitFactory>\n  ? UnionToIntersection<ExtractSelectorsType<ExtractArrayElementTypes<T>>>\n  : T extends BaseFeatureTraits<any, any, infer S>\n  ? S\n  : never;\n\nexport type ExtractMutatorsType<T> = T extends TraitFactory<\n  any,\n  any,\n  any,\n  infer M\n>\n  ? M\n  : T extends ReadonlyArray<TraitFactory>\n  ? UnionToIntersection<ExtractMutatorsType<ExtractArrayElementTypes<T>>>\n  : never;\n\nexport type ExtractKeyedConfigType<T> = T extends TraitFactory<\n  any,\n  any,\n  any,\n  any,\n  infer KEY,\n  infer C\n>\n  ? KeyedConfig<KEY, C>\n  : T extends ReadonlyArray<TraitFactory>\n  ? UnionToIntersection<ExtractKeyedConfigType<ExtractArrayElementTypes<T>>>\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport type PrefixProps<T, P extends string> = {\n  [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K];\n};\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport type PostfixProps<T, P extends string> = {\n  [K in keyof T as `${Uncapitalize<string & K>}${Capitalize<P>}`]: T[K];\n};\n\ntype Replace<\n  Target extends string,\n  FindKey extends string,\n  ReplaceKey extends string\n> = Target extends `${infer Prefix}${FindKey}${infer Postfix}`\n  ? `${Prefix}${Capitalize<ReplaceKey>}${Postfix}`\n  : Target;\n\nexport type ReplaceProps<\n  Target,\n  FindKey extends string,\n  ReplaceKey extends string\n> = {\n  [Prop in keyof Target as Replace<\n    string & Prop,\n    FindKey,\n    ReplaceKey\n  >]: Target[Prop];\n};\nexport type ReplaceEntityNames<\n  T,\n  EntityName extends string,\n  EntitiesName extends string\n> = ReplaceProps<\n  ReplaceProps<T, 'Entities', EntitiesName>,\n  'Entity',\n  EntityName\n>;\n"]}

package/esm2020/ngrx-traits-core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdyeC10cmFpdHMtY29yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29yZS9zcmMvbGliL25ncngtdHJhaXRzLWNvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2020/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29yZS9zcmMvbGliL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/testing/index.mjs

@@ -0,0 +1,2 @@
+export * from './provide-mock-local-traits';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvcmUvdGVzdGluZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZS1tb2NrLWxvY2FsLXRyYWl0cyc7XG4iXX0=

package/esm2020/testing/ngrx-traits-core-testing.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdyeC10cmFpdHMtY29yZS10ZXN0aW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3J4LXRyYWl0cy9jb3JlL3Rlc3Rpbmcvc3JjL25ncngtdHJhaXRzLWNvcmUtdGVzdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/testing/provide-mock-local-traits.mjs

@@ -0,0 +1,36 @@
+import { DISABLE_LOCAL_TRAIT_EFFECTS, } from '@ngrx-traits/core';
+import { Injector } from '@angular/core';
+import { EffectSources } from '@ngrx/effects';
+import { MockStore } from '@ngrx/store/testing';
+/*
+ * NOTE: provideMockStore({initialState}) initialState will be ignored with local traits store!
+ * Override selectors instead
+ *
+ * You still need to provideMockStore and provideMockActions
+ * */
+export function provideMockLocalTraits({ traitFactory, selectors, }) {
+    return [
+        { provide: DISABLE_LOCAL_TRAIT_EFFECTS, useValue: true },
+        {
+            provide: EffectSources,
+            useValue: {
+                addEffects: () => {
+                    return;
+                },
+            },
+        },
+        {
+            provide: traitFactory,
+            deps: [Injector, MockStore],
+            useFactory: (injector, mockStore) => {
+                const trait = new traitFactory(injector);
+                if (selectors) {
+                    Object.keys(selectors).forEach((key) => trait.localSelectors?.[key] &&
+                        mockStore.overrideSelector(trait.localSelectors[key], selectors?.[key]));
+                }
+                return trait;
+            },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29yZS90ZXN0aW5nL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/trait-effect.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { takeUntil } from 'rxjs/operators';
+import { Actions, ofType, } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+import * as i2 from "@ngrx/store";
+export class TraitEffect {
+    constructor(actions$, store) {
+        this.actions$ = actions$;
+        this.store = store;
+        this.name = this.constructor.name;
+        this.componentId = '';
+    }
+    ngrxOnIdentifyEffects() {
+        return this.componentId ? this.name + this.componentId : '';
+    }
+    ngrxOnRunEffects(resolvedEffects$) {
+        return this.componentId
+            ? resolvedEffects$.pipe(takeUntil(this.actions$.pipe(ofType(getDestroyActionName(this.componentId)))))
+            : resolvedEffects$;
+    }
+}
+TraitEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
+export function getDestroyActionName(id) {
+    return `[${id}] Destroyed`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/util.mjs

@@ -0,0 +1,70 @@
+export function insertIf(condition, getElement) {
+    return condition ? [getElement()] : [];
+}
+export function toMap(a) {
+    return a.reduce((acum, value) => {
+        acum[value] = true;
+        return acum;
+    }, {});
+}
+export function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+export function camelCaseToSentence(text) {
+    const result = text.replace(/([A-Z])/g, ' $1');
+    return result.charAt(0).toUpperCase() + result.slice(1);
+}
+/**
+ * Set propertyReducer in sourceReducer in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer, 'selectedProduct', selectedProductReducer)
+ */
+export function setPropertyReducer(sourceReducer, property, propertyReducer) {
+    return function reducer(state, action) {
+        const sourceState = sourceReducer(state, action);
+        return {
+            ...sourceState,
+            [property]: propertyReducer(sourceState[property], action),
+        };
+    };
+}
+/**
+ * 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
+ * })
+ */
+export function setPropertiesReducer(sourceReducer, propertiesReducers) {
+    return function reducer(state, action) {
+        const newState = { ...sourceReducer(state, action) };
+        for (const property in propertiesReducers) {
+            newState[property] = propertiesReducers[property](newState[property], action);
+        }
+        return newState;
+    };
+}
+/**
+ * joins two reducers so the work in the same state
+ * @param firstReducer
+ * @param secondReducer
+ */
+export function joinReducers(firstReducer, secondReducer) {
+    return function reducer(state, action) {
+        const sourceState = firstReducer(state, action);
+        return secondReducer(sourceState, action);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/{ngrx-traits-core-testing.js → ngrx-traits-core-testing.mjs}

@@ -43,4 +43,4 @@ function provideMockLocalTraits({ traitFactory, selectors, }) {
  */
 
 export { provideMockLocalTraits };
-//# sourceMappingURL=ngrx-traits-core-testing.js.map
+//# sourceMappingURL=ngrx-traits-core-testing.mjs.map

package/fesm2015/ngrx-traits-core-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngrx-traits-core-testing.mjs","sources":["../../../../../libs/ngrx-traits/core/testing/src/provide-mock-local-traits.ts","../../../../../libs/ngrx-traits/core/testing/src/ngrx-traits-core-testing.ts"],"sourcesContent":["import {\n  EntityFeatureFactory,\n  TraitsLocalStore,\n  DISABLE_LOCAL_TRAIT_EFFECTS,\n} from '@ngrx-traits/core';\nimport { Injector, Provider, Type } from '@angular/core';\nimport { EffectSources } from '@ngrx/effects';\nimport { MockStore } from '@ngrx/store/testing';\n\n/*\n * NOTE: provideMockStore({initialState}) initialState will be ignored with local traits store!\n * Override selectors instead\n *\n * You still need to provideMockStore and provideMockActions\n * */\nexport function provideMockLocalTraits<\n  T extends TraitsLocalStore<EntityFeatureFactory<any, any>>\n>({\n  traitFactory,\n  selectors,\n}: {\n  traitFactory: Type<T>;\n  selectors?: {\n    [key in keyof T['localSelectors']]?: ReturnType<T['localSelectors'][key]>;\n  };\n}): Provider[] {\n  return [\n    { provide: DISABLE_LOCAL_TRAIT_EFFECTS, useValue: true },\n    {\n      provide: EffectSources,\n      useValue: {\n        addEffects: () => {\n          return;\n        },\n      },\n    },\n    {\n      provide: traitFactory,\n      deps: [Injector, MockStore],\n      useFactory: (injector: Injector, mockStore: MockStore) => {\n        const trait = new traitFactory(injector);\n        if (selectors) {\n          Object.keys(selectors).forEach(\n            (key) =>\n              trait.localSelectors?.[key] &&\n              mockStore.overrideSelector(\n                trait.localSelectors[key],\n                selectors?.[key]\n              )\n          );\n        }\n        return trait;\n      },\n    },\n  ];\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public_api';\n"],"names":[],"mappings":";;;;;AASA;;;;;AAKK;SACW,sBAAsB,CAEpC,EACA,YAAY,EACZ,SAAS,GAMV,EAAA;IACC,OAAO;AACL,QAAA,EAAE,OAAO,EAAE,2BAA2B,EAAE,QAAQ,EAAE,IAAI,EAAE;AACxD,QAAA;AACE,YAAA,OAAO,EAAE,aAAa;AACtB,YAAA,QAAQ,EAAE;gBACR,UAAU,EAAE,MAAK;oBACf,OAAO;iBACR;AACF,aAAA;AACF,SAAA;AACD,QAAA;AACE,YAAA,OAAO,EAAE,YAAY;AACrB,YAAA,IAAI,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC;AAC3B,YAAA,UAAU,EAAE,CAAC,QAAkB,EAAE,SAAoB,KAAI;AACvD,gBAAA,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC;AACzC,gBAAA,IAAI,SAAS,EAAE;oBACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAC5B,CAAC,GAAG,KAAI;;AACN,wBAAA,OAAA,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,cAAc,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAG,GAAG,CAAC;AAC3B,4BAAA,SAAS,CAAC,gBAAgB,CACxB,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,EACzB,SAAS,KAAA,IAAA,IAAT,SAAS,KAAT,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,SAAS,CAAG,GAAG,CAAC,CACjB,CAAA;AAAA,qBAAA,CACJ,CAAC;AACH,iBAAA;AACD,gBAAA,OAAO,KAAK,CAAC;aACd;AACF,SAAA;KACF,CAAC;AACJ;;ACvDA;;AAEG;;;;"}

package/fesm2015/{ngrx-traits-core.js → ngrx-traits-core.mjs}

@@ -497,9 +497,9 @@ class TraitEffect {
             : resolvedEffects$;
     }
 }
-TraitEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
-TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitEffect });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitEffect, decorators: [{
+TraitEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
 function getDestroyActionName(id) {
@@ -648,9 +648,9 @@ class TraitsLocalStore extends TraitEffect {
         this.traits.destroy();
     }
 }
-TraitsLocalStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitsLocalStore });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TraitsLocalStore, decorators: [{
+TraitsLocalStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
@@ -748,9 +748,9 @@ const deleteCache = createAction('[Cache] Delete Cache', props());
  * @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
  */
-function cache({ store, key, source, expires, maxCacheSize, }) {
+function cache({ store, key, source, expires, maxCacheSize, skip, }) {
     const exp = expires !== null && expires !== void 0 ? expires : Infinity;
-    return store.select(selectCache(key)).pipe(first(), concatMap((cache) => cache && isCacheValid(cache, exp)
+    return store.select(selectCache(key)).pipe(first(), concatMap((cache) => cache && !skip && isCacheValid(cache, exp)
         ? of(cache.value).pipe(tap(() => store.dispatch(hitCache({ key }))))
         : source.pipe(tap((value) => store.dispatch(cache$1({
             key,
@@ -900,10 +900,10 @@ function invalidaSubKeys(state) {
 
 class CacheModule {
 }
-CacheModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CacheModule, imports: [i2.StoreFeatureModule] });
-CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CacheModule, providers: [], imports: [[StoreModule.forFeature('cache', cacheReducer)]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CacheModule, decorators: [{
+CacheModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, imports: [i2.StoreFeatureModule] });
+CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, providers: [], imports: [[StoreModule.forFeature('cache', cacheReducer)]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [StoreModule.forFeature('cache', cacheReducer)],
@@ -919,4 +919,4 @@ const CacheSelectors = { getCache: selectCache };
  */
 
 export { CacheActions, CacheModule, CacheSelectors, DISABLE_LOCAL_TRAIT_EFFECTS, TraitEffect, TraitsLocalStore, addEntityFeaturesProperties, buildLocalTraits, cache, camelCaseToSentence, capitalize, combineEntityFeatures, createEntityFeatureFactory, createTraitFactory, getDestroyActionName, insertIf, joinReducers, mixEntityFeatures, setPropertiesReducer, setPropertyReducer, toMap };
-//# sourceMappingURL=ngrx-traits-core.js.map
+//# sourceMappingURL=ngrx-traits-core.mjs.map