@microphi/store 0.2.9 → 1.1.0

package/esm2020/lib/effect/effect.mjs

@@ -0,0 +1,75 @@
+import { scanInstance } from '../utilities/scan-instance';
+export const EffectSymbol = Symbol.for('@Effect');
+/**
+ * Tags a method as an effect <br>
+ *
+ * Strategy is one of the following rxjs pipe-able operators:
+ * - `mergeMap`
+ * - `concatMap`
+ * - `switchMap`
+ *
+ * As an example consider the following:
+ * suppose there's an effect that takes 10 ms to return and then a reducer is called.<br>
+ * Suppose we dispatch its event, the following diagram demonstrate what happens<br>
+ *  <code>
+ * `D -> E -> (10) -> R`<br>
+ *  </code>
+ * Event is dispatched `D`, event is executed `E`, takes 10ms and finally reducer is called with result from `E`
+ *
+ * Now let's suppose we dispatch again the same while `E` is still pending (executing) and suppose we call it with a different argument.
+ *
+ *
+ * `D(a) -> E -> D(b)`
+ *
+ *
+ * what happens next depends on the strategy used.<br>
+ *
+ *
+ * If `switchMap` is used (default)
+ *
+ * `D(a) -> E(a) -> D(b) -> E(b) -> R(b)`
+ *
+ * the second dispatch cancels the first and so only `R(b)` is executed
+ *
+ *
+ * If `mergeMap` is used
+ *
+ * `D(a) -> E(a) -> D(b) -> E(b) -> R(a) -> R(b)
+ *
+ * effects are executed in parallel and the first to come is the first served
+ *
+ * i.e.: lets say E(a) takes longer to respond then
+ *
+ * `D(a) -> D(b) -> E(b) ->  R(b) -> E(a) -> -> R(a)`
+ *
+ *
+ * If `concatMap` is used then the order of calls is respected.
+ *
+ * in the case above we'll have whatever the timings are on the effects
+ *
+ * `D(a) -> D(b) -> E(a) ->  R(a) -> E(b) -> -> R(b)`
+ *
+ * @param strategy
+ * @constructor
+ */
+export function Effect(strategy = 'switchMap') {
+    // return Reflect.metadata(EffectSymbol, strategy);
+    return (target, propertyKey) => {
+        // return Reflect.metadata(EffectSymbol, strategy)(target, propertyKey);
+        return Reflect.defineMetadata(EffectSymbol, strategy, target, propertyKey);
+    };
+}
+export function getEffectMetadata(klass, key) {
+    return Reflect.getMetadata(EffectSymbol, klass, key);
+}
+export function getEffects(instance) {
+    const effects = [];
+    scanInstance(instance, (proto, key) => {
+        const strategy = getEffectMetadata(proto, key);
+        if (strategy) {
+            effects.push({ action: key, strategy, });
+        }
+    });
+    return effects;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/list/list.mjs

@@ -0,0 +1,75 @@
+export class List {
+    constructor(IDField, entities = []) {
+        this.IDField = IDField;
+        this.entities = new Map();
+        /**
+         * maps entities position from the original array to their ids
+         */
+        this.ids = [];
+        this.ids = entities.map((e) => this.getId(e));
+        entities
+            .forEach((item, idx) => {
+            const id = item[IDField];
+            this.entities.set(id, item);
+        });
+    }
+    get size() {
+        if (this.ids.length !== this.entities.size) {
+            throw new Error(`Size Mismatch ${this.ids.length} !== ${this.entities.size}`);
+        }
+        return this.entities.size;
+    }
+    get(id) {
+        return this.entities.get(id);
+    }
+    getId(entity) {
+        return entity[this.IDField];
+    }
+    *[Symbol.iterator]() {
+        // tslint:disable-next-line:forin
+        for (const idx in this.ids) {
+            const id = this.ids[idx];
+            yield this.entities.get(id);
+        }
+    }
+    upsert(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            if (!this.entities.has(id)) {
+                this.ids.push(id);
+            }
+            this.entities.set(id, e);
+        });
+    }
+    prepend(...entities) {
+        entities.reverse().forEach((e) => {
+            const id = this.getId(e);
+            if (this.entities.has(id)) {
+                this.delete(e);
+            }
+            this.ids.unshift(id);
+            this.entities.set(id, e);
+        });
+    }
+    delete(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            const indexOfId = this.ids.findIndex((_id) => _id === id);
+            if (indexOfId >= 0) {
+                this.ids.splice(indexOfId, 1);
+                this.entities.delete(id);
+            }
+        });
+    }
+    append(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            if (this.entities.has(id)) {
+                this.delete(e);
+            }
+            this.ids.push(id);
+            this.entities.set(id, e);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/reduce/reduce.mjs

@@ -0,0 +1,26 @@
+import 'reflect-metadata';
+import { scanInstance } from '../utilities/scan-instance';
+export const ReduceSymbol = Symbol('@Reduce');
+export function Reduce() {
+    return (target, propertyKey) => {
+        // by convention a reducer have name such as onFindAll
+        // where findAll is the associated action
+        // with the following we extract the action's name
+        const action = propertyKey.slice(2, 3).toLowerCase() + propertyKey.slice(3);
+        return Reflect.defineMetadata(ReduceSymbol, action, target, propertyKey);
+    };
+}
+export function getReduceMetadata(klass, key) {
+    return Reflect.getMetadata(ReduceSymbol, klass, key);
+}
+export function getReducers(instance) {
+    const reducers = [];
+    scanInstance(instance, (proto, key) => {
+        const metadata = getReduceMetadata(proto, key);
+        if (metadata) {
+            reducers.push({ action: metadata });
+        }
+    });
+    return reducers;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/store/store.mjs

@@ -0,0 +1,101 @@
+import { BehaviorSubject, EMPTY, of, Subject } from 'rxjs';
+import { getReducers } from '../reduce/reduce';
+import { catchError, concatMap, filter, map, mergeMap, switchMap, tap, withLatestFrom } from 'rxjs/operators';
+import { getEffects } from '../effect/effect';
+export class Store {
+    constructor(initialState) {
+        this.initialState = initialState;
+        this.actions = new Map();
+        this._loading$ = new Subject();
+        this._store$ = new BehaviorSubject(
+        // we need this in order to decouple initial state between instances
+        JSON.parse(JSON.stringify(this.initialState)));
+        this.effects = getEffects(this);
+        this.reducers = getReducers(this);
+        const actions = [].concat(this.effects, this.reducers);
+        const actionsSet = new Set();
+        actions.forEach(({ action }) => actionsSet.add(action));
+        actionsSet.forEach((key) => {
+            this.actions.set(key, new Subject());
+            // @ts-ignore
+            const operator = Store.getOperator(this.effects[key]?.strategy);
+            // @ts-ignore
+            this.actions.get(key).pipe(withLatestFrom(this._store$), tap(([{ payload }]) => {
+                this._loading$.next({
+                    payload: payload,
+                    status: true,
+                    code: key,
+                });
+            }), operator(([{ name, payload }]) => {
+                // @ts-ignore
+                return this[name](...payload).pipe(tap((response) => {
+                    this._loading$.next({
+                        payload,
+                        response,
+                        status: false,
+                        // here the action is done. The action is the only async call
+                        // we can assume the loading is done as the effect is not async
+                        code: key,
+                    });
+                }), 
+                // the above is
+                map((response) => {
+                    // by convention reducer name must be
+                    // on + Action
+                    const reducerName = `on${(name[0]).toUpperCase()}${name.slice(1)}`;
+                    // @ts-ignore
+                    return this[reducerName](this._store$.getValue(), response);
+                }), 
+                // error need to be swallowed here too otherwise the observable chain will be broken
+                // meaning that once an action goes into an error it cannot be dispatched again
+                catchError((error) => this.swallowError(key, error, payload)));
+            })).subscribe(this._store$);
+        });
+    }
+    get loading$() {
+        return this._loading$.asObservable();
+    }
+    get state$() {
+        return this._store$.asObservable();
+    }
+    select(projection) {
+        return this.state$.pipe(map(projection));
+    }
+    getLoadingFor(action) {
+        return this.loading$.pipe(filter(({ code }) => code === action), map(({ status }) => status));
+    }
+    dispatch(action, ...payload) {
+        if (!this.actions.has(action)) {
+            throw new Error(`Cannot find action ${String(action)}`);
+        }
+        const name = (typeof this[action] === 'function' ? action : 'noopEffect');
+        this.actions.get(action)?.next({ name, payload });
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    static noopEffect(payload) {
+        return of(payload);
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    static getOperator(strategyFn) {
+        if (strategyFn === 'mergeMap') {
+            return mergeMap;
+        }
+        else if (strategyFn === 'concatMap') {
+            return concatMap;
+        }
+        else {
+            return switchMap;
+        }
+    }
+    swallowError(key, error, payload) {
+        console.log(`Error handling action "${key}"`, error);
+        this._loading$.next({
+            payload,
+            error: error,
+            status: false,
+            code: key,
+        });
+        return EMPTY;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../projects/store/src/lib/store/store.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, EMPTY, Observable, of, Subject } from 'rxjs';\nimport { getReducers, Reducer } from '../reduce/reduce';\nimport { catchError, concatMap, filter, map, mergeMap, switchMap, tap, withLatestFrom } from 'rxjs/operators';\nimport { Effect, EffectStrategy, getEffects } from '../effect/effect';\nimport { Brand, Primitive } from 'utility-types';\n\nexport type getPayloadFromActionType<A, C extends keyof A> =\n  A[C] extends Function ? A[C] extends () => any\n    ? never[] : A[C] extends (...args: infer T) => any\n      ? T : never[] : A[C][];\n\nexport type PureReducer<T extends Primitive> = Brand<T, 'reducer'>;\n\nexport type makeEffects<Actions> = {\n  // Effects\n  [k in keyof Actions]: Actions[k] extends PureReducer<Primitive>\n    ? never\n    : Actions[k]\n}\n\nexport type makeStore<State, Actions> =\n  {\n    [k in keyof makeEffects<Actions>]: makeEffects<Actions>[k]\n  }\n  // &\n  // Actions\n  &\n  {\n    // Reducers\n    [k in keyof Actions as `on${Capitalize<string & k>}`]: Actions[k] extends (...args: any) => Observable<infer O>\n    ? (state: State, payload: O) => State\n    : Actions[k] extends PureReducer<infer O>\n      ? (state?: State, payload?: O) => State\n      : (state?: State) => State\n\n  };\n\nexport interface LoadingState<A> {\n  code: keyof A;\n  payload?: any;\n  response?: any;\n  error?: any;\n  status: boolean;\n}\n\nexport abstract class Store<State, A> {\n\n  private readonly actions: Map<string, Subject<{ name: string, payload?: any }>> = new Map();\n\n  readonly effects: Effect[];\n\n  readonly reducers: Reducer[];\n\n\n  private _loading$ = new Subject<LoadingState<A>>();\n\n  public get loading$(): Observable<LoadingState<A>> {\n    return this._loading$.asObservable();\n  }\n\n  protected readonly _store$: BehaviorSubject<State> = new BehaviorSubject<State>(\n    // we need this in order to decouple initial state between instances\n    JSON.parse(JSON.stringify(this.initialState))\n  );\n\n  public get state$(): Observable<State> {\n    return this._store$.asObservable();\n  }\n\n  constructor(private initialState: State) {\n\n    this.effects = getEffects(this);\n    this.reducers = getReducers(this);\n\n    const actions = [].concat(this.effects, this.reducers);\n\n    const actionsSet = new Set<string>();\n\n    actions.forEach(({action}) => actionsSet.add(action));\n\n    actionsSet.forEach((key) => {\n\n      this.actions.set(key, new Subject());\n\n      // @ts-ignore\n      const operator = Store.getOperator(this.effects[key]?.strategy);\n\n      // @ts-ignore\n      this.actions.get(key).pipe(\n        withLatestFrom(this._store$),\n        tap(([{payload}]) => {\n          this._loading$.next({\n            payload: payload,\n            status: true,\n            code: key as keyof A,\n          });\n        }),\n        operator(([{name, payload}]) => {\n          // @ts-ignore\n          return this[name](...payload).pipe(\n            tap((response) => {\n              this._loading$.next({\n                payload,\n                response,\n                status: false,\n                // here the action is done. The action is the only async call\n                // we can assume the loading is done as the effect is not async\n                code: key as keyof A,\n              });\n            }),\n            // the above is\n            map((response) => {\n              // by convention reducer name must be\n              // on + Action\n              const reducerName = `on${(name[0]).toUpperCase()}${(name as string).slice(1)}`;\n\n              // @ts-ignore\n              return this[reducerName](this._store$.getValue(), response);\n            }),\n            // error need to be swallowed here too otherwise the observable chain will be broken\n            // meaning that once an action goes into an error it cannot be dispatched again\n            catchError((error) => this.swallowError(key, error, payload)),\n          );\n        }),\n        // @ts-ignore\n      ).subscribe(this._store$);\n    });\n  }\n\n  select<R>(projection: (s: State) => R) {\n    return this.state$.pipe(\n      map(projection)\n    );\n  }\n\n  getLoadingFor<C extends keyof A>(action: C): Observable<boolean> {\n    return this.loading$.pipe(\n      filter(({code}) => code === action),\n      map(({status}) => status),\n    );\n  }\n\n  dispatch<C extends keyof A>(\n    action: C,\n    ...payload: getPayloadFromActionType<A, C>\n  ) {\n\n    if (!this.actions.has(action as string)) {\n      throw new Error(`Cannot find action ${String(action)}`);\n    }\n\n    const name: string = (typeof (this as unknown as A)[action] === 'function' ? action : 'noopEffect') as string;\n\n\n    this.actions.get(action as string)?.next({name, payload});\n  }\n\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  private static noopEffect(payload: any) {\n    return of(payload);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  private static getOperator(strategyFn: EffectStrategy) {\n    if (strategyFn === 'mergeMap') {\n      return mergeMap;\n    } else if (strategyFn === 'concatMap') {\n      return concatMap;\n    } else {\n      return switchMap;\n    }\n  }\n\n  private swallowError(key: string, error: Error, payload: any) {\n    console.log(`Error handling action \"${key}\"`, error);\n\n    this._loading$.next({\n      payload,\n      error: error,\n      status: false,\n      code: key as keyof A,\n    });\n\n    return EMPTY;\n  }\n\n}\n"]}

package/esm2020/lib/utilities/scan-instance.mjs

@@ -0,0 +1,19 @@
+const builtInMethods = Object.keys(Object.getOwnPropertyDescriptors(Object.getPrototypeOf({})));
+export function scanInstance(instance, cb) {
+    let proto = Object.getPrototypeOf(instance);
+    while (proto) {
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        Object.keys(descriptors)
+            .filter((k) => {
+            return !builtInMethods.includes(k);
+        })
+            .forEach((key) => cb(proto, key));
+        try {
+            proto = Object.getPrototypeOf(proto);
+        }
+        catch (e) {
+            proto = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nhbi1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N0b3JlL3NyYy9saWIvdXRpbGl0aWVzL3NjYW4taW5zdGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxjQUFjLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMseUJBQXlCLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFFaEcsTUFBTSxVQUFVLFlBQVksQ0FBbUIsUUFBVyxFQUFFLEVBQTBDO0lBRXBHLElBQUksS0FBSyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsUUFBUSxDQUFDLENBQUM7SUFFNUMsT0FBTyxLQUFLLEVBQUU7UUFFWixNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMseUJBQXlCLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFNUQsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUM7YUFDckIsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7WUFDWixPQUFPLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNyQyxDQUFDLENBQUM7YUFDRCxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUVwQyxJQUFJO1lBQ0YsS0FBSyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDdEM7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUNWLEtBQUssR0FBRyxJQUFJLENBQUM7U0FDZDtLQUNGO0FBRUgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsYXNzIH0gZnJvbSAndXRpbGl0eS10eXBlcyc7XG5cbmNvbnN0IGJ1aWx0SW5NZXRob2RzID0gT2JqZWN0LmtleXMoT2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoT2JqZWN0LmdldFByb3RvdHlwZU9mKHt9KSkpO1xuXG5leHBvcnQgZnVuY3Rpb24gc2Nhbkluc3RhbmNlPFQgZXh0ZW5kcyBvYmplY3Q+KGluc3RhbmNlOiBULCBjYjogKHByb3RvOiBDbGFzczxUPiwga2V5OiBzdHJpbmcpID0+IHZvaWQpIHtcblxuICBsZXQgcHJvdG8gPSBPYmplY3QuZ2V0UHJvdG90eXBlT2YoaW5zdGFuY2UpO1xuXG4gIHdoaWxlIChwcm90bykge1xuXG4gICAgY29uc3QgZGVzY3JpcHRvcnMgPSBPYmplY3QuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhwcm90byk7XG5cbiAgICBPYmplY3Qua2V5cyhkZXNjcmlwdG9ycylcbiAgICAgIC5maWx0ZXIoKGspID0+IHtcbiAgICAgICAgcmV0dXJuICFidWlsdEluTWV0aG9kcy5pbmNsdWRlcyhrKTtcbiAgICAgIH0pXG4gICAgICAuZm9yRWFjaCgoa2V5KSA9PiBjYihwcm90bywga2V5KSk7XG5cbiAgICB0cnkge1xuICAgICAgcHJvdG8gPSBPYmplY3QuZ2V0UHJvdG90eXBlT2YocHJvdG8pO1xuICAgIH0gY2F0Y2ggKGUpIHtcbiAgICAgIHByb3RvID0gbnVsbDtcbiAgICB9XG4gIH1cblxufVxuIl19

package/esm2020/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of store
+ */
+export * from './lib/store/store';
+export * from './lib/effect/effect';
+export * from './lib/reduce/reduce';
+export * from './lib/list/list';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N0b3JlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygc3RvcmVcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdG9yZS9zdG9yZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lZmZlY3QvZWZmZWN0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlZHVjZS9yZWR1Y2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGlzdC9saXN0JztcbiJdfQ==

package/fesm2015/microphi-store.mjs

@@ -0,0 +1,305 @@
+import { Subject, BehaviorSubject, of, EMPTY } from 'rxjs';
+import 'reflect-metadata';
+import { withLatestFrom, tap, map, catchError, filter, mergeMap, concatMap, switchMap } from 'rxjs/operators';
+
+const builtInMethods = Object.keys(Object.getOwnPropertyDescriptors(Object.getPrototypeOf({})));
+function scanInstance(instance, cb) {
+    let proto = Object.getPrototypeOf(instance);
+    while (proto) {
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        Object.keys(descriptors)
+            .filter((k) => {
+            return !builtInMethods.includes(k);
+        })
+            .forEach((key) => cb(proto, key));
+        try {
+            proto = Object.getPrototypeOf(proto);
+        }
+        catch (e) {
+            proto = null;
+        }
+    }
+}
+
+const ReduceSymbol = Symbol('@Reduce');
+function Reduce() {
+    return (target, propertyKey) => {
+        // by convention a reducer have name such as onFindAll
+        // where findAll is the associated action
+        // with the following we extract the action's name
+        const action = propertyKey.slice(2, 3).toLowerCase() + propertyKey.slice(3);
+        return Reflect.defineMetadata(ReduceSymbol, action, target, propertyKey);
+    };
+}
+function getReduceMetadata(klass, key) {
+    return Reflect.getMetadata(ReduceSymbol, klass, key);
+}
+function getReducers(instance) {
+    const reducers = [];
+    scanInstance(instance, (proto, key) => {
+        const metadata = getReduceMetadata(proto, key);
+        if (metadata) {
+            reducers.push({ action: metadata });
+        }
+    });
+    return reducers;
+}
+
+const EffectSymbol = Symbol.for('@Effect');
+/**
+ * Tags a method as an effect <br>
+ *
+ * Strategy is one of the following rxjs pipe-able operators:
+ * - `mergeMap`
+ * - `concatMap`
+ * - `switchMap`
+ *
+ * As an example consider the following:
+ * suppose there's an effect that takes 10 ms to return and then a reducer is called.<br>
+ * Suppose we dispatch its event, the following diagram demonstrate what happens<br>
+ *  <code>
+ * `D -> E -> (10) -> R`<br>
+ *  </code>
+ * Event is dispatched `D`, event is executed `E`, takes 10ms and finally reducer is called with result from `E`
+ *
+ * Now let's suppose we dispatch again the same while `E` is still pending (executing) and suppose we call it with a different argument.
+ *
+ *
+ * `D(a) -> E -> D(b)`
+ *
+ *
+ * what happens next depends on the strategy used.<br>
+ *
+ *
+ * If `switchMap` is used (default)
+ *
+ * `D(a) -> E(a) -> D(b) -> E(b) -> R(b)`
+ *
+ * the second dispatch cancels the first and so only `R(b)` is executed
+ *
+ *
+ * If `mergeMap` is used
+ *
+ * `D(a) -> E(a) -> D(b) -> E(b) -> R(a) -> R(b)
+ *
+ * effects are executed in parallel and the first to come is the first served
+ *
+ * i.e.: lets say E(a) takes longer to respond then
+ *
+ * `D(a) -> D(b) -> E(b) ->  R(b) -> E(a) -> -> R(a)`
+ *
+ *
+ * If `concatMap` is used then the order of calls is respected.
+ *
+ * in the case above we'll have whatever the timings are on the effects
+ *
+ * `D(a) -> D(b) -> E(a) ->  R(a) -> E(b) -> -> R(b)`
+ *
+ * @param strategy
+ * @constructor
+ */
+function Effect(strategy = 'switchMap') {
+    // return Reflect.metadata(EffectSymbol, strategy);
+    return (target, propertyKey) => {
+        // return Reflect.metadata(EffectSymbol, strategy)(target, propertyKey);
+        return Reflect.defineMetadata(EffectSymbol, strategy, target, propertyKey);
+    };
+}
+function getEffectMetadata(klass, key) {
+    return Reflect.getMetadata(EffectSymbol, klass, key);
+}
+function getEffects(instance) {
+    const effects = [];
+    scanInstance(instance, (proto, key) => {
+        const strategy = getEffectMetadata(proto, key);
+        if (strategy) {
+            effects.push({ action: key, strategy, });
+        }
+    });
+    return effects;
+}
+
+class Store {
+    constructor(initialState) {
+        this.initialState = initialState;
+        this.actions = new Map();
+        this._loading$ = new Subject();
+        this._store$ = new BehaviorSubject(
+        // we need this in order to decouple initial state between instances
+        JSON.parse(JSON.stringify(this.initialState)));
+        this.effects = getEffects(this);
+        this.reducers = getReducers(this);
+        const actions = [].concat(this.effects, this.reducers);
+        const actionsSet = new Set();
+        actions.forEach(({ action }) => actionsSet.add(action));
+        actionsSet.forEach((key) => {
+            var _a;
+            this.actions.set(key, new Subject());
+            // @ts-ignore
+            const operator = Store.getOperator((_a = this.effects[key]) === null || _a === void 0 ? void 0 : _a.strategy);
+            // @ts-ignore
+            this.actions.get(key).pipe(withLatestFrom(this._store$), tap(([{ payload }]) => {
+                this._loading$.next({
+                    payload: payload,
+                    status: true,
+                    code: key,
+                });
+            }), operator(([{ name, payload }]) => {
+                // @ts-ignore
+                return this[name](...payload).pipe(tap((response) => {
+                    this._loading$.next({
+                        payload,
+                        response,
+                        status: false,
+                        // here the action is done. The action is the only async call
+                        // we can assume the loading is done as the effect is not async
+                        code: key,
+                    });
+                }), 
+                // the above is
+                map((response) => {
+                    // by convention reducer name must be
+                    // on + Action
+                    const reducerName = `on${(name[0]).toUpperCase()}${name.slice(1)}`;
+                    // @ts-ignore
+                    return this[reducerName](this._store$.getValue(), response);
+                }), 
+                // error need to be swallowed here too otherwise the observable chain will be broken
+                // meaning that once an action goes into an error it cannot be dispatched again
+                catchError((error) => this.swallowError(key, error, payload)));
+            })).subscribe(this._store$);
+        });
+    }
+    get loading$() {
+        return this._loading$.asObservable();
+    }
+    get state$() {
+        return this._store$.asObservable();
+    }
+    select(projection) {
+        return this.state$.pipe(map(projection));
+    }
+    getLoadingFor(action) {
+        return this.loading$.pipe(filter(({ code }) => code === action), map(({ status }) => status));
+    }
+    dispatch(action, ...payload) {
+        var _a;
+        if (!this.actions.has(action)) {
+            throw new Error(`Cannot find action ${String(action)}`);
+        }
+        const name = (typeof this[action] === 'function' ? action : 'noopEffect');
+        (_a = this.actions.get(action)) === null || _a === void 0 ? void 0 : _a.next({ name, payload });
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    static noopEffect(payload) {
+        return of(payload);
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    static getOperator(strategyFn) {
+        if (strategyFn === 'mergeMap') {
+            return mergeMap;
+        }
+        else if (strategyFn === 'concatMap') {
+            return concatMap;
+        }
+        else {
+            return switchMap;
+        }
+    }
+    swallowError(key, error, payload) {
+        console.log(`Error handling action "${key}"`, error);
+        this._loading$.next({
+            payload,
+            error: error,
+            status: false,
+            code: key,
+        });
+        return EMPTY;
+    }
+}
+
+class List {
+    constructor(IDField, entities = []) {
+        this.IDField = IDField;
+        this.entities = new Map();
+        /**
+         * maps entities position from the original array to their ids
+         */
+        this.ids = [];
+        this.ids = entities.map((e) => this.getId(e));
+        entities
+            .forEach((item, idx) => {
+            const id = item[IDField];
+            this.entities.set(id, item);
+        });
+    }
+    get size() {
+        if (this.ids.length !== this.entities.size) {
+            throw new Error(`Size Mismatch ${this.ids.length} !== ${this.entities.size}`);
+        }
+        return this.entities.size;
+    }
+    get(id) {
+        return this.entities.get(id);
+    }
+    getId(entity) {
+        return entity[this.IDField];
+    }
+    *[Symbol.iterator]() {
+        // tslint:disable-next-line:forin
+        for (const idx in this.ids) {
+            const id = this.ids[idx];
+            yield this.entities.get(id);
+        }
+    }
+    upsert(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            if (!this.entities.has(id)) {
+                this.ids.push(id);
+            }
+            this.entities.set(id, e);
+        });
+    }
+    prepend(...entities) {
+        entities.reverse().forEach((e) => {
+            const id = this.getId(e);
+            if (this.entities.has(id)) {
+                this.delete(e);
+            }
+            this.ids.unshift(id);
+            this.entities.set(id, e);
+        });
+    }
+    delete(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            const indexOfId = this.ids.findIndex((_id) => _id === id);
+            if (indexOfId >= 0) {
+                this.ids.splice(indexOfId, 1);
+                this.entities.delete(id);
+            }
+        });
+    }
+    append(...entities) {
+        entities.forEach((e) => {
+            const id = this.getId(e);
+            if (this.entities.has(id)) {
+                this.delete(e);
+            }
+            this.ids.push(id);
+            this.entities.set(id, e);
+        });
+    }
+}
+
+/*
+ * Public API Surface of store
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Effect, EffectSymbol, List, Reduce, ReduceSymbol, Store, getEffectMetadata, getEffects, getReduceMetadata, getReducers };
+//# sourceMappingURL=microphi-store.mjs.map