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

package/esm2020/create-entity-feature.mjs

@@ -0,0 +1,404 @@
+import { combineReducers, createFeatureSelector, createReducer, createSelector, } from '@ngrx/store';
+import { capitalize, setPropertiesReducer } from './util';
+/**
+ * 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',
+ * });
+ */
+export function createEntityFeatureFactory(namesOrFactory, ...traits) {
+    return ((config) => {
+        const { entityName, entitiesName } = 'entityName' in namesOrFactory
+            ? namesOrFactory
+            : { entityName: 'Entity', entitiesName: 'Entities' };
+        const singular = capitalize(entityName);
+        const plural = entitiesName
+            ? capitalize(entitiesName)
+            : capitalize(entityName + 's');
+        const sortedTraits = sortTraits('entityName' in namesOrFactory ? [...traits] : [namesOrFactory, ...traits]);
+        const allConfigs = buildAllConfigs(sortedTraits);
+        const allActions = buildAllActions(sortedTraits, config.actionsGroupKey, singular, plural, allConfigs);
+        const allSelectors = buildAllSelectors(sortedTraits, allConfigs);
+        const allMutators = buildAllMutators(sortedTraits, allSelectors, allConfigs);
+        const initialState = buildInitialState(sortedTraits, allConfigs);
+        const reducer = buildReducer(sortedTraits, initialState, allActions, allSelectors, allMutators, allConfigs);
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const allFeatureSelectors = allSelectors && getSelectorsForFeature(featureSelector, allSelectors);
+        const allEffects = buildAllEffects(sortedTraits, allActions, allFeatureSelectors, allConfigs);
+        return {
+            actions: entityName
+                ? renameProps(allActions, singular, plural)
+                : allActions,
+            selectors: entityName
+                ? renameProps(allFeatureSelectors, singular, plural)
+                : allSelectors,
+            initialState,
+            reducer: reducer ?? createReducer(initialState),
+            effects: allEffects,
+        };
+    });
+}
+function renameProps(target, entityName, entitiesName) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        const newKey = key
+            .replace('Entities', entitiesName)
+            .replace('Entity', entityName);
+        result[newKey] = value;
+    }
+    return result;
+}
+function sortTraits(traits) {
+    const sortedTraits = [];
+    for (let i = 0; i < traits.length; i++) {
+        const trait = traits[i];
+        if (!trait.depends?.length) {
+            sortedTraits.push(trait);
+            continue;
+        }
+        if (trait.depends.length > 1)
+            for (const d of trait.depends) {
+                const isTraitPresent = traits.some((tr) => tr.key === d);
+                if (isTraitPresent) {
+                    trait.depends = [d];
+                    break;
+                }
+            }
+        if (trait.depends.length > 1)
+            throw Error('could not find dependencies ' + trait.depends.join(' '));
+        const isDependencyAlreadyAdded = sortedTraits.some((tr) => tr.key === trait?.depends?.[0]);
+        if (isDependencyAlreadyAdded)
+            sortedTraits.push(trait);
+        else {
+            // move trait to the end
+            delete traits[i];
+            traits.push(trait);
+        }
+    }
+    return sortedTraits;
+}
+function buildAllConfigs(sortedTraits) {
+    return sortedTraits.reduce((acc, factory) => {
+        acc[factory.key] = factory.config;
+        return acc;
+    }, {});
+}
+function buildAllActions(sortedTraits, actionsGroupKey, entityName, entitiesName, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.actions?.({
+            actionsGroupKey: actionsGroupKey,
+            entityName,
+            entitiesName,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {});
+}
+function buildAllSelectors(sortedTraits, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.selectors?.({
+            previousSelectors: previousResult,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {});
+}
+function buildAllMutators(sortedTraits, allSelectors, allConfigs) {
+    return (sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.mutators?.({
+            allSelectors: allSelectors,
+            previousMutators: previousResult,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {}) || {});
+}
+function buildInitialState(sortedTraits, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        const result = factory?.initialState?.({
+            previousInitialState: previousResult,
+            allConfigs,
+        }) ??
+            previousResult ??
+            {};
+        return result;
+    }, {});
+}
+function buildReducer(sortedTraits, initialState, allActions, allSelectors, allMutators, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        const result = factory?.reducer?.({
+            initialState,
+            allActions,
+            allSelectors,
+            allMutators,
+            allConfigs,
+        });
+        return result && previousResult
+            ? (state = initialState, action) => {
+                const aState = previousResult(state, action);
+                return result(aState, action);
+            }
+            : result ?? previousResult;
+    }, undefined);
+}
+function buildAllEffects(sortedTraits, allActions, allFeatureSelectors, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.effects?.({
+            allActions,
+            allSelectors: allFeatureSelectors,
+            allConfigs,
+        }) ?? [];
+        result = previousResult ? [...previousResult, ...result] : result;
+        return result;
+    }, []);
+}
+function getSelectorsForFeature(featureSelect, selectors) {
+    const ss = {};
+    for (const prop in selectors) {
+        ss[prop] = createSelector(featureSelect, selectors[prop]);
+    }
+    return ss;
+}
+/**
+ * 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();
+ */
+export function combineEntityFeatures(traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const actions = {};
+        const selectors = {};
+        const reducers = {};
+        let effects = [];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions[key] = featureTraits.actions;
+            selectors[key] = featureTraits.selectors;
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: combineReducers(reducers),
+            effects,
+        };
+    });
+}
+/**
+ * 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();
+ *
+ */
+export function mixEntityFeatures(traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        let actions = {};
+        let selectors = {};
+        const reducers = {};
+        let effects = [];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions = { ...actions, ...featureTraits.actions };
+            selectors = { ...selectors, ...featureTraits.selectors };
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: combineReducers(reducers),
+            effects,
+        };
+    });
+}
+/**
+ * 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();
+ */
+export function addEntityFeaturesProperties(targetTraitFactory, traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const targetFeatureTraits = targetTraitFactory({
+            actionsGroupKey: config.actionsGroupKey,
+            featureSelector: featureSelector,
+        });
+        const actions = { ...targetFeatureTraits.actions };
+        const selectors = { ...targetFeatureTraits.selectors };
+        const reducers = {};
+        let effects = [...targetFeatureTraits.effects];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions[key] = featureTraits.actions;
+            selectors[key] = featureTraits.selectors;
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: setPropertiesReducer(targetFeatureTraits.reducer, reducers),
+            effects,
+        };
+    });
+}
+/**
+ * Helper function to create an implementation  a TraitFactory
+ * @param f TraitFactory implementation
+ */
+export function createTraitFactory(f) {
+    return f;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-entity-feature.js","sourceRoot":"","sources":["../../../../../libs/ngrx-traits/core/src/lib/create-entity-feature.ts"],"names":[],"mappings":"AAoBA,OAAO,EAGL,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,cAAc,GAEf,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAiF1D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,0BAA0B,CAKxC,cAEgB,EAChB,GAAG,MAAS;IAQZ,OAAO,CAAC,CAAC,MAAwB,EAAE,EAAE;QACnC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAChC,YAAY,IAAI,cAAc;YAC5B,CAAC,CAAE,cAGC;YACJ,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC;QAEzD,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,YAAY;YACzB,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC;YAC1B,CAAC,CAAC,UAAU,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC;QAEjC,MAAM,YAAY,GAAG,UAAU,CAC7B,YAAY,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,GAAG,MAAM,CAAC,CAC3E,CAAC;QAEF,MAAM,UAAU,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC;QAEjD,MAAM,UAAU,GAAG,eAAe,CAChC,YAAY,EACZ,MAAM,CAAC,eAAe,EACtB,QAAQ,EACR,MAAM,EACN,UAAU,CACX,CAAC;QAEF,MAAM,YAAY,GAAG,iBAAiB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAEjE,MAAM,WAAW,GAAG,gBAAgB,CAClC,YAAY,EACZ,YAAY,EACZ,UAAU,CACX,CAAC;QAEF,MAAM,YAAY,GAAG,iBAAiB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAEjE,MAAM,OAAO,GAAG,YAAY,CAC1B,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,WAAW,EACX,UAAU,CACX,CAAC;QAEF,MAAM,eAAe,GACnB,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ;YACxC,CAAC,CAAC,qBAAqB,CAAsB,MAAM,CAAC,eAAe,CAAC;YACpE,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;QAE7B,MAAM,mBAAmB,GACvB,YAAY,IAAI,sBAAsB,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;QAExE,MAAM,UAAU,GAAG,eAAe,CAChC,YAAY,EACZ,UAAU,EACV,mBAAmB,EACnB,UAAU,CACX,CAAC;QAEF,OAAO;YACL,OAAO,EAAE,UAAU;gBACjB,CAAC,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC;gBAC3C,CAAC,CAAC,UAAU;YACd,SAAS,EAAE,UAAU;gBACnB,CAAC,CAAC,WAAW,CAAC,mBAAmB,EAAE,QAAQ,EAAE,MAAM,CAAC;gBACpD,CAAC,CAAC,YAAY;YAChB,YAAY;YACZ,OAAO,EAAE,OAAO,IAAI,aAAa,CAAC,YAAY,CAAC;YAC/C,OAAO,EAAE,UAAU;SACpB,CAAC;IACJ,CAAC,CAMA,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,MAAW,EAAE,UAAkB,EAAE,YAAoB;IACxE,MAAM,MAAM,GAAG,EAAS,CAAC;IACzB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACjD,MAAM,MAAM,GAAG,GAAG;aACf,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC;aACjC,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACjC,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;KACxB;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,UAAU,CACjB,MAA0C;IAE1C,MAAM,YAAY,GAAuC,EAAE,CAAC;IAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE;YAC1B,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,SAAS;SACV;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAC1B,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE;gBAC7B,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;gBACzD,IAAI,cAAc,EAAE;oBAClB,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;oBACpB,MAAM;iBACP;aACF;QACH,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAC1B,MAAM,KAAK,CAAC,8BAA8B,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACxE,MAAM,wBAAwB,GAAG,YAAY,CAAC,IAAI,CAChD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CACvC,CAAC;QAEF,IAAI,wBAAwB;YAAE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAClD;YACH,wBAAwB;YACxB,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;KACF;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,SAAS,eAAe,CAAC,YAAgD;IACvE,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,GAA6B,EAAE,OAAO,EAAE,EAAE;QACpE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QAClC,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,eAAe,CACtB,YAAgD,EAChD,eAAuB,EACvB,UAAkB,EAClB,YAAoB,EACpB,UAAsD;IAEtD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,cAA4B,EAAE,OAAO,EAAE,EAAE;QACnE,IAAI,MAAM,GACR,OAAO,EAAE,OAAO,EAAE,CAAC;YACjB,eAAe,EAAE,eAAe;YAChC,UAAU;YACV,YAAY;YACZ,UAAU;SACX,CAAC,IAAI,EAAE,CAAC;QACX,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QACpE,OAAO,MAAM,CAAC;IAChB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,iBAAiB,CACxB,YAAgD,EAChD,UAAsD;IAEtD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,cAAmC,EAAE,OAAO,EAAE,EAAE;QAC1E,IAAI,MAAM,GACR,OAAO,EAAE,SAAS,EAAE,CAAC;YACnB,iBAAiB,EAAE,cAAc;YACjC,UAAU;SACX,CAAC,IAAI,EAAE,CAAC;QACX,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QACpE,OAAO,MAAM,CAAC;IAChB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,gBAAgB,CACvB,YAAgD,EAChD,YAAiC,EACjC,UAAsD;IAEtD,OAAO,CACL,YAAY,CAAC,MAAM,CACjB,CAAC,cAAmD,EAAE,OAAO,EAAE,EAAE;QAC/D,IAAI,MAAM,GACR,OAAO,EAAE,QAAQ,EAAE,CAAC;YAClB,YAAY,EAAE,YAAY;YAC1B,gBAAgB,EAAE,cAAc;YAChC,UAAU;SACX,CAAC,IAAI,EAAE,CAAC;QACX,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QACpE,OAAO,MAAM,CAAC;IAChB,CAAC,EACD,EAAE,CACH,IAAI,EAAE,CACR,CAAC;AACJ,CAAC;AAED,SAAS,iBAAiB,CACxB,YAAgD,EAChD,UAAsD;IAEtD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,cAAmB,EAAE,OAAO,EAAE,EAAE;QAC1D,MAAM,MAAM,GACV,OAAO,EAAE,YAAY,EAAE,CAAC;YACtB,oBAAoB,EAAE,cAAc;YACpC,UAAU;SACX,CAAC;YACF,cAAc;YACd,EAAE,CAAC;QACL,OAAO,MAAM,CAAC;IAChB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,YAAY,CACnB,YAAgD,EAChD,YAAiB,EACjB,UAAwB,EACxB,YAAiC,EACjC,WAAoC,EACpC,UAAsD;IAEtD,OAAO,YAAY,CAAC,MAAM,CACxB,CACE,cAAiE,EACjE,OAAO,EACP,EAAE;QACF,MAAM,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC;YAChC,YAAY;YACZ,UAAU;YACV,YAAY;YACZ,WAAW;YACX,UAAU;SACX,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,cAAc;YAC7B,CAAC,CAAC,CAAC,KAAK,GAAG,YAAY,EAAE,MAAM,EAAE,EAAE;gBAC/B,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBAC7C,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAChC,CAAC;YACH,CAAC,CAAC,MAAM,IAAI,cAAc,CAAC;IAC/B,CAAC,EACD,SAAS,CACV,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CACtB,YAAgD,EAChD,UAAwB,EACxB,mBAAwC,EACxC,UAAsD;IAEtD,OAAO,YAAY,CAAC,MAAM,CACxB,CAAC,cAA+C,EAAE,OAAO,EAAE,EAAE;QAC3D,IAAI,MAAM,GACR,OAAO,EAAE,OAAO,EAAE,CAAC;YACjB,UAAU;YACV,YAAY,EAAE,mBAAmB;YACjC,UAAU;SACX,CAAC,IAAI,EAAE,CAAC;QACX,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAClE,OAAO,MAAM,CAAC;IAChB,CAAC,EACD,EAAE,CACH,CAAC;AACJ,CAAC;AAED,SAAS,sBAAsB,CAK7B,aAAgB,EAAE,SAAY;IAC9B,MAAM,EAAE,GAA+B,EAAE,CAAC;IAC1C,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE;QAC5B,EAAE,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,aAAoB,EAAE,SAAS,CAAC,IAAI,CAAQ,CAAC,CAAC;KACzE;IACD,OAAO,EAAgC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,qBAAqB,CAenC,iBAAoB;IACpB,OAAO,CAAC,CAAC,MAAwB,EAAE,EAAE;QACnC,MAAM,eAAe,GACnB,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ;YACxC,CAAC,CAAC,qBAAqB,CAAM,MAAM,CAAC,eAAe,CAAC;YACpD,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;QAC7B,MAAM,OAAO,GAAQ,EAAE,CAAC;QACxB,MAAM,SAAS,GAAQ,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,OAAO,GAAgB,EAAE,CAAC;QAC9B,KAAK,MAAM,CAAC,GAAG,EAAE,oBAAoB,CAAC,IAAI,MAAM,CAAC,OAAO,CACtD,iBAAiB,CAClB,EAAE;YACD,MAAM,QAAQ,GAAG,cAAc,CAC7B,eAAe,EACf,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAC3B,CAAC;YACF,MAAM,aAAa,GAAG,oBAAoB,CAAC;gBACzC,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,QAAQ;aAC1B,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC;YACrC,SAAS,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,SAAS,CAAC;YACzC,QAAQ,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC;YACtC,OAAO,GAAG,CAAC,GAAG,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;SAClD;QACD,OAAO;YACL,OAAO;YACP,SAAS;YACT,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC;YAClC,OAAO;SACR,CAAC;IACJ,CAAC,CAAM,CAAC;AACV,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,iBAAiB,CAW/B,iBAAoB;IACpB,OAAO,CAAC,CAAC,MAAwB,EAAE,EAAE;QACnC,MAAM,eAAe,GACnB,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ;YACxC,CAAC,CAAC,qBAAqB,CAAM,MAAM,CAAC,eAAe,CAAC;YACpD,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;QAC7B,IAAI,OAAO,GAAQ,EAAE,CAAC;QACtB,IAAI,SAAS,GAAQ,EAAE,CAAC;QACxB,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,OAAO,GAAgB,EAAE,CAAC;QAC9B,KAAK,MAAM,CAAC,GAAG,EAAE,oBAAoB,CAAC,IAAI,MAAM,CAAC,OAAO,CACtD,iBAAiB,CAClB,EAAE;YACD,MAAM,QAAQ,GAAG,cAAc,CAC7B,eAAe,EACf,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAC3B,CAAC;YACF,MAAM,aAAa,GAAG,oBAAoB,CAAC;gBACzC,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,QAAQ;aAC1B,CAAC,CAAC;YACH,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC;YACnD,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,GAAG,aAAa,CAAC,SAAS,EAAE,CAAC;YACzD,QAAQ,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC;YACtC,OAAO,GAAG,CAAC,GAAG,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;SAClD;QACD,OAAO;YACL,OAAO;YACP,SAAS;YACT,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC;YAClC,OAAO;SACR,CAAC;IACJ,CAAC,CAAM,CAAC;AACV,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,2BAA2B,CAqBzC,kBAAqB,EAAE,iBAAoB;IAC3C,OAAO,CAAC,CAAC,MAAwB,EAAE,EAAE;QACnC,MAAM,eAAe,GACnB,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ;YACxC,CAAC,CAAC,qBAAqB,CAAM,MAAM,CAAC,eAAe,CAAC;YACpD,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;QAC7B,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;YAC7C,eAAe,EAAE,MAAM,CAAC,eAAe;YACvC,eAAe,EAAE,eAAe;SACjC,CAAC,CAAC;QACH,MAAM,OAAO,GAAQ,EAAE,GAAG,mBAAmB,CAAC,OAAO,EAAE,CAAC;QACxD,MAAM,SAAS,GAAQ,EAAE,GAAG,mBAAmB,CAAC,SAAS,EAAE,CAAC;QAC5D,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,OAAO,GAAgB,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAC5D,KAAK,MAAM,CAAC,GAAG,EAAE,oBAAoB,CAAC,IAAI,MAAM,CAAC,OAAO,CACtD,iBAAiB,CAClB,EAAE;YACD,MAAM,QAAQ,GAAG,cAAc,CAC7B,eAAe,EACf,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAC3B,CAAC;YACF,MAAM,aAAa,GAAG,oBAAoB,CAAC;gBACzC,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,QAAQ;aAC1B,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC;YACrC,SAAS,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,SAAS,CAAC;YACzC,QAAQ,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC;YACtC,OAAO,GAAG,CAAC,GAAG,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;SAClD;QACD,OAAO;YACL,OAAO;YACP,SAAS;YACT,OAAO,EAAE,oBAAoB,CAAC,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC;YACpE,OAAO;SACR,CAAC;IACJ,CAAC,CAAM,CAAC;AACV,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAQhC,CAUD;IACC,OAAO,CAA6C,CAAC;AACvD,CAAC","sourcesContent":["import {\n  Config,\n  ExtractActionsType,\n  ExtractSelectorsType,\n  ExtractStateType,\n  EntityFeatureFactory,\n  FeatureSelectors,\n  KeyedConfig,\n  TraitActions,\n  TraitFactory,\n  TraitSelectors,\n  TraitStateMutators,\n  UnionToIntersection,\n  TraitActionsFactory,\n  TraitSelectorsFactory,\n  TraitInitialStateFactory,\n  TraitStateMutatorsFactory,\n  TraitReducerFactory,\n  TraitEffectsFactory,\n} from './model';\nimport {\n  Action,\n  ActionType,\n  combineReducers,\n  createFeatureSelector,\n  createReducer,\n  createSelector,\n  MemoizedSelector,\n} from '@ngrx/store';\nimport { TraitEffect } from './trait-effect';\nimport { Type } from './local-store';\nimport { capitalize, setPropertiesReducer } from './util';\n\n/**\n * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory\n * which combines all the traits actions, selectors , reducers and effects,\n * the names param will replace any action and selector with the word Entity or Entities,\n * with the corresponding entityName and  entitiesName param (entityName+'s' if entitiesName is omitted).\n * @param namesConfig - Optional Names for entities\n * @param namesConfig.entityName - singular name for entity\n * @param [namesConfig.entitiesName] - plural name for entities, defaults to entityName + 's'\n * @param traits set of traits to be combined\n *\n * @example\n *\n * const featureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntityTrait<Product>(),\n *   addAsyncActionTrait({\n *     name: 'checkout',\n *     actionSuccessProps: props<{ orderId: string }>(),\n *   })\n * );\n *\n * export const productsFeature = featureFactory({\n *   actionsGroupKey: '[Products]',\n *   featureSelector: 'products',\n * });\n */\nexport function createEntityFeatureFactory<\n  F extends readonly TraitFactory[],\n  EntityName extends string,\n  EntitiesName extends string = `${EntityName}s`\n>(\n  {\n    entityName,\n    entitiesName,\n  }: { entityName: EntityName; entitiesName?: EntitiesName },\n  ...traits: F\n): EntityFeatureFactory<\n  EntityName,\n  EntitiesName,\n  ExtractStateType<F>,\n  ExtractActionsType<F>,\n  ExtractSelectorsType<F>\n>;\n\n/**\n * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory\n * which combines all the traits actions, selectors , reducers and effects.\n * @param traits set of traits to be combined\n *\n * @example\n *\n * const featureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntityTrait<Product>(),\n *   addAsyncActionTrait({\n *     name: 'checkout',\n *     actionSuccessProps: props<{ orderId: string }>(),\n *   })\n * );\n *\n * export const productsFeature = featureFactory({\n *   actionsGroupKey: '[Products]',\n *   featureSelector: 'products',\n * });\n *\n * productsFeature.actions.loadProducts();\n */\nexport function createEntityFeatureFactory<F extends readonly TraitFactory[]>(\n  ...traits: F\n): EntityFeatureFactory<\n  'Entity',\n  'Entities',\n  ExtractStateType<F>,\n  ExtractActionsType<F>,\n  ExtractSelectorsType<F>\n>;\n\n/**\n * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory\n * which combines all the traits actions, selectors , reducers and effects,\n * the names param will replace any action and selector with the word Entity or Entities,\n * with the corresponding entityName and  entitiesName param (entityName+'s' if entitiesName is omitted).\n * @param namesConfig - Optional Names for entities\n * @param namesConfig.entityName - singular name for entity\n * @param [namesConfig.entitiesName] - plural name for entities, defaults to entityName + 's'\n * @param traits set of traits to be combined\n *\n * @example\n *\n * const featureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntityTrait<Product>(),\n *   addAsyncActionTrait({\n *     name: 'checkout',\n *     actionSuccessProps: props<{ orderId: string }>(),\n *   })\n * );\n *\n * export const productsFeature = featureFactory({\n *   actionsGroupKey: '[Products]',\n *   featureSelector: 'products',\n * });\n */\nexport function createEntityFeatureFactory<\n  F extends readonly TraitFactory[],\n  EntityName extends string,\n  EntitiesName extends string = `${EntityName}s`\n>(\n  namesOrFactory:\n    | { entityName: EntityName; entitiesName?: EntitiesName }\n    | TraitFactory,\n  ...traits: F\n): EntityFeatureFactory<\n  EntityName,\n  EntitiesName,\n  ExtractStateType<F>,\n  ExtractActionsType<F>,\n  ExtractSelectorsType<F>\n> {\n  return ((config: Config<any, any>) => {\n    const { entityName, entitiesName } =\n      'entityName' in namesOrFactory\n        ? (namesOrFactory as {\n            entityName: EntityName;\n            entitiesName?: EntitiesName;\n          })\n        : { entityName: 'Entity', entitiesName: 'Entities' };\n\n    const singular = capitalize(entityName);\n    const plural = entitiesName\n      ? capitalize(entitiesName)\n      : capitalize(entityName + 's');\n\n    const sortedTraits = sortTraits(\n      'entityName' in namesOrFactory ? [...traits] : [namesOrFactory, ...traits]\n    );\n\n    const allConfigs = buildAllConfigs(sortedTraits);\n\n    const allActions = buildAllActions(\n      sortedTraits,\n      config.actionsGroupKey,\n      singular,\n      plural,\n      allConfigs\n    );\n\n    const allSelectors = buildAllSelectors(sortedTraits, allConfigs);\n\n    const allMutators = buildAllMutators(\n      sortedTraits,\n      allSelectors,\n      allConfigs\n    );\n\n    const initialState = buildInitialState(sortedTraits, allConfigs);\n\n    const reducer = buildReducer(\n      sortedTraits,\n      initialState,\n      allActions,\n      allSelectors,\n      allMutators,\n      allConfigs\n    );\n\n    const featureSelector =\n      typeof config.featureSelector === 'string'\n        ? createFeatureSelector<ExtractStateType<F>>(config.featureSelector)\n        : config.featureSelector;\n\n    const allFeatureSelectors =\n      allSelectors && getSelectorsForFeature(featureSelector, allSelectors);\n\n    const allEffects = buildAllEffects(\n      sortedTraits,\n      allActions,\n      allFeatureSelectors,\n      allConfigs\n    );\n\n    return {\n      actions: entityName\n        ? renameProps(allActions, singular, plural)\n        : allActions,\n      selectors: entityName\n        ? renameProps(allFeatureSelectors, singular, plural)\n        : allSelectors,\n      initialState,\n      reducer: reducer ?? createReducer(initialState),\n      effects: allEffects,\n    };\n  }) as EntityFeatureFactory<\n    EntityName,\n    EntitiesName,\n    ExtractStateType<F>,\n    ExtractActionsType<F>,\n    ExtractSelectorsType<F>\n  >;\n}\n\nfunction renameProps(target: any, entityName: string, entitiesName: string) {\n  const result = {} as any;\n  for (const [key, value] of Object.entries(target)) {\n    const newKey = key\n      .replace('Entities', entitiesName)\n      .replace('Entity', entityName);\n    result[newKey] = value;\n  }\n  return result;\n}\n\nfunction sortTraits(\n  traits: TraitFactory<any, any, any, any>[]\n): TraitFactory<any, any, any, any>[] {\n  const sortedTraits: TraitFactory<any, any, any, any>[] = [];\n  for (let i = 0; i < traits.length; i++) {\n    const trait = traits[i];\n    if (!trait.depends?.length) {\n      sortedTraits.push(trait);\n      continue;\n    }\n    if (trait.depends.length > 1)\n      for (const d of trait.depends) {\n        const isTraitPresent = traits.some((tr) => tr.key === d);\n        if (isTraitPresent) {\n          trait.depends = [d];\n          break;\n        }\n      }\n    if (trait.depends.length > 1)\n      throw Error('could not find dependencies ' + trait.depends.join(' '));\n    const isDependencyAlreadyAdded = sortedTraits.some(\n      (tr) => tr.key === trait?.depends?.[0]\n    );\n\n    if (isDependencyAlreadyAdded) sortedTraits.push(trait);\n    else {\n      // move trait to the end\n      delete traits[i];\n      traits.push(trait);\n    }\n  }\n  return sortedTraits;\n}\n\nfunction buildAllConfigs(sortedTraits: TraitFactory<any, any, any, any>[]) {\n  return sortedTraits.reduce((acc: KeyedConfig<string, any>, factory) => {\n    acc[factory.key] = factory.config;\n    return acc;\n  }, {});\n}\n\nfunction buildAllActions(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  actionsGroupKey: string,\n  entityName: string,\n  entitiesName: string,\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return sortedTraits.reduce((previousResult: TraitActions, factory) => {\n    let result =\n      factory?.actions?.({\n        actionsGroupKey: actionsGroupKey,\n        entityName,\n        entitiesName,\n        allConfigs,\n      }) ?? {};\n    result = previousResult ? { ...previousResult, ...result } : result;\n    return result;\n  }, {});\n}\n\nfunction buildAllSelectors(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return sortedTraits.reduce((previousResult: TraitSelectors<any>, factory) => {\n    let result =\n      factory?.selectors?.({\n        previousSelectors: previousResult,\n        allConfigs,\n      }) ?? {};\n    result = previousResult ? { ...previousResult, ...result } : result;\n    return result;\n  }, {});\n}\n\nfunction buildAllMutators(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  allSelectors: TraitSelectors<any>,\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return (\n    sortedTraits.reduce(\n      (previousResult: TraitStateMutators<any> | undefined, factory) => {\n        let result =\n          factory?.mutators?.({\n            allSelectors: allSelectors,\n            previousMutators: previousResult,\n            allConfigs,\n          }) ?? {};\n        result = previousResult ? { ...previousResult, ...result } : result;\n        return result;\n      },\n      {}\n    ) || {}\n  );\n}\n\nfunction buildInitialState(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return sortedTraits.reduce((previousResult: any, factory) => {\n    const result =\n      factory?.initialState?.({\n        previousInitialState: previousResult,\n        allConfigs,\n      }) ??\n      previousResult ??\n      {};\n    return result;\n  }, {});\n}\n\nfunction buildReducer(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  initialState: any,\n  allActions: TraitActions,\n  allSelectors: TraitSelectors<any>,\n  allMutators: TraitStateMutators<any>,\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return sortedTraits.reduce(\n    (\n      previousResult: ((state: any, action: Action) => any) | undefined,\n      factory\n    ) => {\n      const result = factory?.reducer?.({\n        initialState,\n        allActions,\n        allSelectors,\n        allMutators,\n        allConfigs,\n      });\n      return result && previousResult\n        ? (state = initialState, action) => {\n            const aState = previousResult(state, action);\n            return result(aState, action);\n          }\n        : result ?? previousResult;\n    },\n    undefined\n  );\n}\n\nfunction buildAllEffects(\n  sortedTraits: TraitFactory<any, any, any, any>[],\n  allActions: TraitActions,\n  allFeatureSelectors: TraitSelectors<any>,\n  allConfigs: Record<string, any> & { [p: string]: any }\n) {\n  return sortedTraits.reduce(\n    (previousResult: Type<TraitEffect>[] | undefined, factory) => {\n      let result =\n        factory?.effects?.({\n          allActions,\n          allSelectors: allFeatureSelectors,\n          allConfigs,\n        }) ?? [];\n      result = previousResult ? [...previousResult, ...result] : result;\n      return result;\n    },\n    []\n  );\n}\n\nfunction getSelectorsForFeature<\n  State,\n  S extends TraitSelectors<State>,\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  F extends MemoizedSelector<object, any>\n>(featureSelect: F, selectors: S): FeatureSelectors<State, S> {\n  const ss: { [key in keyof S]?: any } = {};\n  for (const prop in selectors) {\n    ss[prop] = createSelector(featureSelect as any, selectors[prop] as any);\n  }\n  return ss as FeatureSelectors<State, S>;\n}\n\n/**\n * Combine a map entityFeatureFactories into one,\n * grouping the actions and selectors by the key of the respective entityFeatureFactory\n * @param traitFactoriesMap\n *\n * @example\n *\n * const clientsFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'client', entitiesName: 'clients' },\n *   addLoadEntitiesTrait<Client>(),\n *   addCrudEntitiesTrait<Client>()\n * );\n *\n * const productOrderFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'productOrder' },\n *   addLoadEntitiesTrait<ProductOrder>(),\n *   addSelectEntitiesTrait<ProductOrder>()\n * );\n *\n * const productFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntitiesTrait<Product>()\n * );\n *\n * const productCombinedFactory = combineEntityFeatures({\n *   products: productFeatureFactory,\n *   productOrders: productOrderFeatureFactory,\n *   clients: clientsFeatureFactory,\n * });\n *\n * const combinedFeature = productCombinedFactory({\n *     actionsGroupKey: '[Combined]',\n *     featureSelector: 'combined',\n *   });\n *\n *   combinedFeature.actions.client.loadClients();\n *   combinedFeature.actions.product.loadProducts();\n */\nexport function combineEntityFeatures<\n  T extends { [key: string]: EntityFeatureFactory<any, any> },\n  K extends keyof T,\n  State extends { [P in K]: ExtractStateType<ReturnType<T[P]>> },\n  A extends { [P in K]: ExtractActionsType<ReturnType<T[P]>> },\n  S extends {\n    [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;\n  },\n  R extends (config: Config<State>) => {\n    actions: A;\n    selectors: S;\n    reducer: (state: State, action: ActionType<any>) => State;\n    effects: Type<any>[];\n    initialState: State;\n  }\n>(traitFactoriesMap: T): R {\n  return ((config: Config<any, any>) => {\n    const featureSelector =\n      typeof config.featureSelector === 'string'\n        ? createFeatureSelector<any>(config.featureSelector)\n        : config.featureSelector;\n    const actions: any = {};\n    const selectors: any = {};\n    const reducers: any = {};\n    let effects: Type<any>[] = [];\n    for (const [key, entityFeatureFactory] of Object.entries(\n      traitFactoriesMap\n    )) {\n      const selector = createSelector(\n        featureSelector,\n        (state: any) => state[key]\n      );\n      const featureTraits = entityFeatureFactory({\n        actionsGroupKey: config.actionsGroupKey,\n        featureSelector: selector,\n      });\n      actions[key] = featureTraits.actions;\n      selectors[key] = featureTraits.selectors;\n      reducers[key] = featureTraits.reducer;\n      effects = [...effects, ...featureTraits.effects];\n    }\n    return {\n      actions,\n      selectors,\n      reducer: combineReducers(reducers),\n      effects,\n    };\n  }) as R;\n}\n\n/**\n * 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\n * internal in the reducers and selector to separate the state\n * @param traitFactoriesMap\n *\n * @example\n *\n * const clientsFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'client', entitiesName: 'clients' },\n *   addLoadEntitiesTrait<Client>(),\n *   addCrudEntitiesTrait<Client>()\n * );\n *\n * const productOrderFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'productOrder' },\n *   addLoadEntitiesTrait<ProductOrder>(),\n *   addSelectEntitiesTrait<ProductOrder>()\n * );\n *\n * const productFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntitiesTrait<Product>()\n * );\n *\n * const productMixedFactory = mixEntityFeatures({\n *   products: productFeatureFactory,\n *   productOrders: productOrderFeatureFactory,\n *   clients: clientsFeatureFactory,\n * });\n *\n * const mixedFeature = productMixedFactory({\n *     actionsGroupKey: '[Mixed]',\n *     featureSelector: 'mixed',\n *   });\n * mixedFeature.actions.loadClients();\n * mixedFeature.actions.loadProducts();\n *\n */\nexport function mixEntityFeatures<\n  T extends { [key: string]: EntityFeatureFactory<any, any> },\n  K extends keyof T,\n  State extends { [P in K]: ExtractStateType<ReturnType<T[P]>> },\n  A extends TraitActions &\n    UnionToIntersection<ExtractActionsType<ReturnType<T[K]>>>,\n  S extends TraitSelectors<any> &\n    UnionToIntersection<\n      FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[K]>>>\n    >,\n  R extends EntityFeatureFactory<any, any, State, A, S>\n>(traitFactoriesMap: T): R {\n  return ((config: Config<any, any>) => {\n    const featureSelector =\n      typeof config.featureSelector === 'string'\n        ? createFeatureSelector<any>(config.featureSelector)\n        : config.featureSelector;\n    let actions: any = {};\n    let selectors: any = {};\n    const reducers: any = {};\n    let effects: Type<any>[] = [];\n    for (const [key, entityFeatureFactory] of Object.entries(\n      traitFactoriesMap\n    )) {\n      const selector = createSelector(\n        featureSelector,\n        (state: any) => state[key]\n      );\n      const featureTraits = entityFeatureFactory({\n        actionsGroupKey: config.actionsGroupKey,\n        featureSelector: selector,\n      });\n      actions = { ...actions, ...featureTraits.actions };\n      selectors = { ...selectors, ...featureTraits.selectors };\n      reducers[key] = featureTraits.reducer;\n      effects = [...effects, ...featureTraits.effects];\n    }\n    return {\n      actions,\n      selectors,\n      reducer: combineReducers(reducers),\n      effects,\n    };\n  }) as R;\n}\n\n/**\n * Combines targetTraitFactory with the traitFactoriesMap using the keys as props for the targetTraitFactory state,\n * and grouping the combined actions by key\n * @param targetTraitFactory\n * @param traitFactoriesMap\n *\n * @example\n *\n * const clientsFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'client', entitiesName: 'clients' },\n *   addLoadEntitiesTrait<Client>(),\n *   addCrudEntitiesTrait<Client>()\n * );\n *\n * const productOrderFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'productOrder' },\n *   addLoadEntitiesTrait<ProductOrder>(),\n *   addSelectEntitiesTrait<ProductOrder>()\n * );\n *\n * const productFeatureFactory = createEntityFeatureFactory(\n *   { entityName: 'product' },\n *   addLoadEntitiesTrait<Product>(),\n *   addSelectEntitiesTrait<Product>()\n * );\n *\n * const productAddEntityPropertiesFactory = addEntityFeaturesProperties(\n *   productFeatureFactory,\n *   {\n *     productOrders: productOrderFeatureFactory,\n *     clients: clientsFeatureFactory,\n *   }\n * );\n *\n * const combinedFeature = productAddEntityPropertiesFactory({\n *     actionsGroupKey: '[addEntityFeatures]',\n *     featureSelector: 'addEntityFeatures',\n *   });\n *\n *   combinedFeature.actions.loadProducts();\n *   combinedFeature.actions.clients.loadClients();\n *   combinedFeature.actions.productOrders.loadProductOrders();\n */\nexport function addEntityFeaturesProperties<\n  F extends EntityFeatureFactory<any, any>,\n  T extends { [key: string]: EntityFeatureFactory<any, any, any, any, any> },\n  K extends keyof T,\n  State extends ExtractStateType<ReturnType<F>> &\n    {\n      [P in K]: ExtractStateType<ReturnType<T[P]>>;\n    },\n  A extends ExtractActionsType<ReturnType<F>> &\n    { [P in K]: ExtractActionsType<ReturnType<T[P]>> },\n  S extends FeatureSelectors<State, ExtractSelectorsType<ReturnType<F>>> &\n    {\n      [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;\n    },\n  R extends (config: Config<State>) => {\n    actions: A;\n    selectors: S;\n    reducer: (state: State, action: ActionType<any>) => State;\n    effects: Type<any>[];\n    initialState: State;\n  }\n>(targetTraitFactory: F, traitFactoriesMap: T): R {\n  return ((config: Config<any, any>) => {\n    const featureSelector =\n      typeof config.featureSelector === 'string'\n        ? createFeatureSelector<any>(config.featureSelector)\n        : config.featureSelector;\n    const targetFeatureTraits = targetTraitFactory({\n      actionsGroupKey: config.actionsGroupKey,\n      featureSelector: featureSelector,\n    });\n    const actions: any = { ...targetFeatureTraits.actions };\n    const selectors: any = { ...targetFeatureTraits.selectors };\n    const reducers: any = {};\n    let effects: Type<any>[] = [...targetFeatureTraits.effects];\n    for (const [key, entityFeatureFactory] of Object.entries(\n      traitFactoriesMap\n    )) {\n      const selector = createSelector(\n        featureSelector,\n        (state: any) => state[key]\n      );\n      const featureTraits = entityFeatureFactory({\n        actionsGroupKey: config.actionsGroupKey,\n        featureSelector: selector,\n      });\n      actions[key] = featureTraits.actions;\n      selectors[key] = featureTraits.selectors;\n      reducers[key] = featureTraits.reducer;\n      effects = [...effects, ...featureTraits.effects];\n    }\n    return {\n      actions,\n      selectors,\n      reducer: setPropertiesReducer(targetFeatureTraits.reducer, reducers),\n      effects,\n    };\n  }) as R;\n}\n\n/**\n * Helper function to create an implementation  a TraitFactory\n * @param f TraitFactory implementation\n */\nexport function createTraitFactory<\n  State = {},\n  A extends TraitActions = {},\n  S extends TraitSelectors<State> = {},\n  M extends TraitStateMutators<State> = {},\n  KEY extends string = string,\n  C = unknown,\n  KC = KeyedConfig<KEY, C>\n>(f: {\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}): TraitFactory<State, A, S, M, KEY, C, KC> {\n  return f as TraitFactory<State, A, S, M, KEY, C, KC>;\n}\n"]}

package/esm2020/index.mjs

@@ -0,0 +1,7 @@
+export * from './create-entity-feature';
+export * from './model';
+export * from './local-store';
+export * from './trait-effect';
+export * from './util';
+export * from './cache';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvcmUvc3JjL2xpYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1lbnRpdHktZmVhdHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbG9jYWwtc3RvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi90cmFpdC1lZmZlY3QnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vY2FjaGUnO1xuIl19

package/esm2020/local-store/disable-local-trait-effects.token.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * @ignore
+ * @internal
+ */
+export const DISABLE_LOCAL_TRAIT_EFFECTS = new InjectionToken('disableLocalTraitEffects');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzYWJsZS1sb2NhbC10cmFpdC1lZmZlY3RzLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3J4LXRyYWl0cy9jb3JlL3NyYy9saWIvbG9jYWwtc3RvcmUvZGlzYWJsZS1sb2NhbC10cmFpdC1lZmZlY3RzLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQzNELDBCQUEwQixDQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBAaWdub3JlXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNvbnN0IERJU0FCTEVfTE9DQUxfVFJBSVRfRUZGRUNUUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxib29sZWFuPihcbiAgJ2Rpc2FibGVMb2NhbFRyYWl0RWZmZWN0cydcbik7XG4iXX0=

package/esm2020/local-store/index.mjs

@@ -0,0 +1,3 @@
+export * from './traits-local-store';
+export * from './disable-local-trait-effects.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvcmUvc3JjL2xpYi9sb2NhbC1zdG9yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyYWl0cy1sb2NhbC1zdG9yZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rpc2FibGUtbG9jYWwtdHJhaXQtZWZmZWN0cy50b2tlbic7XG4iXX0=