@ngrx-traits/core 12.1.1 → 12.1.2

package/fesm2015/ngrx-traits-core.js

@@ -23,10 +23,84 @@ function camelCaseToSentence(text) {
     const result = text.replace(/([A-Z])/g, ' $1');
     return result.charAt(0).toUpperCase() + result.slice(1);
 }
-
-function createTraitFactory(f) {
-    return f;
+/**
+ * Set propertyReducer in sourceReducer in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer, 'selectedProduct', selectedProductReducer)
+ */
+function setPropertyReducer(sourceReducer, property, propertyReducer) {
+    return function reducer(state, action) {
+        const sourceState = sourceReducer(state, action);
+        return Object.assign(Object.assign({}, 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
+ * })
+ */
+function setPropertiesReducer(sourceReducer, propertiesReducers) {
+    return function reducer(state, action) {
+        const newState = Object.assign({}, 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
+ */
+function joinReducers(firstReducer, secondReducer) {
+    return function reducer(state, action) {
+        const sourceState = firstReducer(state, action);
+        return secondReducer(sourceState, action);
+    };
+}
+
+/**
+ * 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',
+ * });
+ */
 function createEntityFeatureFactory(namesOrFactory, ...traits) {
     return ((config) => {
         const { entityName, entitiesName } = 'entityName' in namesOrFactory
@@ -190,27 +264,45 @@ function getSelectorsForFeature(featureSelect, selectors) {
     }
     return ss;
 }
-function setPropertyReducer(sourceReducer, property, propertyReducer) {
-    return function reducer(state, action) {
-        const sourceState = sourceReducer(state, action);
-        return Object.assign(Object.assign({}, sourceState), { [property]: propertyReducer(sourceState[property], action) });
-    };
-}
-function setPropertiesReducer(sourceReducer, propertiesReducers) {
-    return function reducer(state, action) {
-        const newState = Object.assign({}, sourceReducer(state, action));
-        for (const property in propertiesReducers) {
-            newState[property] = propertiesReducers[property](newState[property], action);
-        }
-        return newState;
-    };
-}
-function joinReducers(firstReducer, secondReducer) {
-    return function reducer(state, action) {
-        const sourceState = firstReducer(state, action);
-        return secondReducer(sourceState, action);
-    };
-}
+/**
+ * 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();
+ */
 function combineEntityFeatures(traitFactoriesMap) {
     return ((config) => {
         const featureSelector = typeof config.featureSelector === 'string'
@@ -239,6 +331,45 @@ function combineEntityFeatures(traitFactoriesMap) {
         };
     });
 }
+/**
+ * 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();
+ *
+ */
 function mixEntityFeatures(traitFactoriesMap) {
     return ((config) => {
         const featureSelector = typeof config.featureSelector === 'string'
@@ -267,6 +398,49 @@ function mixEntityFeatures(traitFactoriesMap) {
         };
     });
 }
+/**
+ * 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();
+ */
 function addEntityFeaturesProperties(targetTraitFactory, traitFactoriesMap) {
     return ((config) => {
         const featureSelector = typeof config.featureSelector === 'string'
@@ -299,38 +473,13 @@ function addEntityFeaturesProperties(targetTraitFactory, traitFactoriesMap) {
         };
     });
 }
-// export
-/// products:{actions, selectors, }, orders: {actions,slectors}
-/// { actions: {ProductActions, OrderActions}, selectors: {ProductSelectors, OrderSelectors}
-// TODO finish implementing combineTrais and addPropertiesTraits
-// TODO finish renaming traits
-
-// type G = ReplaceProps<
-//   ReplaceProps<
-//     {
-//       loadEntities: 1;
-//       loadEntitiesSuccess: 2;
-//       selectEntities: 3;
-//       selectEntity: 4;
-//     },
-//     'Entities',
-//     'products'
-//   >,
-//   'Entity',
-//   'product'
-// >;
-//
-// const g: G = {};
-// // g.
-//   type F= ReplaceEntityNames<{
-//   loadEntities: 1;
-//   loadEntitiesSuccess: 2;
-//   selectEntities: 3;
-//   selectEntity: 4;
-// }, 'product','products'>;
-// const f: F = {};
-// f.
-// TODO clean up file
+/**
+ * Helper function to create an implementation  a TraitFactory
+ * @param f TraitFactory implementation
+ */
+function createTraitFactory(f) {
+    return f;
+}
 
 class TraitEffect {
     constructor(actions$, store) {
@@ -348,9 +497,9 @@ class TraitEffect {
             : resolvedEffects$;
     }
 }
-TraitEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", 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.1.2", ngImport: i0, type: TraitEffect });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitEffect, decorators: [{
+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: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
 function getDestroyActionName(id) {
@@ -358,6 +507,7 @@ function getDestroyActionName(id) {
 }
 
 /**
+ * @ignore
  * @internal
  */
 const DISABLE_LOCAL_TRAIT_EFFECTS = new InjectionToken('disableLocalTraitEffects');
@@ -366,6 +516,18 @@ 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
+ */
 function buildLocalTraits(injector, componentName, traitFactory) {
     var _a;
     const reducers = injector.get(ReducerManager);
@@ -412,6 +574,67 @@ function buildLocalTraits(injector, componentName, traitFactory) {
         },
     };
 }
+/**
+ * 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());
+ *   }
+ * }
+ */
 class TraitsLocalStore extends TraitEffect {
     constructor(injector) {
         super(injector.get(Actions), injector.get(Store));
@@ -425,9 +648,9 @@ class TraitsLocalStore extends TraitEffect {
         this.traits.destroy();
     }
 }
-TraitsLocalStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitsLocalStore });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitsLocalStore, decorators: [{
+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: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
@@ -677,10 +900,10 @@ function invalidaSubKeys(state) {
 
 class CacheModule {
 }
-CacheModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, imports: [i2.StoreFeatureModule] });
-CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, providers: [], imports: [[StoreModule.forFeature('cache', cacheReducer)]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, decorators: [{
+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: [{
             type: NgModule,
             args: [{
                     imports: [StoreModule.forFeature('cache', cacheReducer)],