Helpers

package.json

@@ -23,9 +23,9 @@
   "license": "AGPL-3.0",
   "devDependencies": {
     "ts-loader": "^2.1.0",
-    "tslint": "^5.4.2",
+    "tslint": "^5.7.0",
     "tslint-loader": "^3.5.3",
-    "typescript": "^2.3.4",
+    "typescript": "^2.5.2",
     "uglifyjs": "^2.4.11",
     "webpack": "^2.6.1"
   },

src/dispatcher.ts

@@ -4,7 +4,7 @@ export interface DispatcherMessage<TAction> {
     action: TAction;
 }
 
-export class DispatcherBuilder extends flux.Dispatcher<DispatcherMessage<any>> {
+export class DispatcherClass extends flux.Dispatcher<DispatcherMessage<any>> {
     /**
      * Dispatches a payload to all registered callbacks.
      *
@@ -26,4 +26,4 @@ export class DispatcherBuilder extends flux.Dispatcher<DispatcherMessage<any>> {
     }
 }
 
-export const Dispatcher = new DispatcherBuilder();
+export const Dispatcher = new DispatcherClass();

src/helpers.ts

@@ -0,0 +1,3 @@
+export { ItemIsPending } from "./helpers/item-is-pending";
+export { ItemsStatusResolver } from "./helpers/items-status-resolver";
+export { WaitForStoreChange } from "./helpers/wait-for-store-changes";

src/helpers/item-is-pending.ts

@@ -0,0 +1,5 @@
+import { ItemStatus } from "../abstractions";
+
+export function ItemIsPending(status: ItemStatus): boolean {
+    return (status <= ItemStatus.Pending);
+}

src/helpers/items-status-resolver.ts

@@ -0,0 +1,33 @@
+import { ItemStatus } from "../abstractions";
+
+export function ItemsStatusResolver(...statuses: ItemStatus[]): ItemStatus {
+    let loadedCount: number = 0;
+    let noDataCount: number = 0;
+    let pendingCount: number = 0;
+
+    for (let i = 0; i < statuses.length; i++) {
+        const status = statuses[i];
+        switch (status) {
+            case ItemStatus.Failed:
+                return status;
+            case ItemStatus.Loaded:
+                loadedCount++;
+                break;
+            case ItemStatus.NoData:
+                noDataCount++;
+                break;
+            case ItemStatus.Init:
+            case ItemStatus.Pending:
+                pendingCount++;
+                break;
+        }
+    }
+
+    if (pendingCount > 0) {
+        return ItemStatus.Pending;
+    } else if (loadedCount === 0 && noDataCount > 0) {
+        return ItemStatus.NoData;
+    } else {
+        return ItemStatus.Loaded;
+    }
+}

src/helpers/wait-for-store-change.ts

@@ -0,0 +1,10 @@
+import { Store } from "flux/utils";
+
+export async function WaitForStoreChange(store: Store<any>): Promise<void> {
+    return new Promise<void>(resolve => {
+        const listener = store.addListener(() => {
+            listener.remove();
+            resolve();
+        });
+    });
+}

src/index.ts

@@ -2,13 +2,15 @@ export * from "./dispatcher";
 export * from "./stores/map-store";
 export * from "./stores/data-store";
 export * from "./stores/reduce-store";
-export * from "./emmitters/actions-emmitter";
+export * from "./emitters/actions-emitter";
 import * as Actions from "./actions/actions";
 import * as Abstractions from "./abstractions";
 import * as Contracts from "./contracts";
+import * as Helpers from "./helpers";
 
 export {
   Actions,
   Abstractions,
-  Contracts
+  Contracts,
+  Helpers
 };

src/stores/map-store.ts

@@ -408,7 +408,9 @@ export abstract class MapStore<TValue> extends ReduceStore<Items<TValue>> {
                 for (let i = 0; i < moveList.length; i++) {
                     let key = moveList[i];
                     let item = this.queuesHandler.Get(key);
-                    stateMap.set(key, { ...item });
+                    if (item != null) {
+                        stateMap.set(key, { ...item });
+                    }
                     this.queuesHandler.Remove(key);
                 }
             });

src/stores/reduce-store.ts

@@ -1,7 +1,7 @@
 import * as Flux from "flux";
 import { ReduceStore as FluxReduceStore } from "flux/utils";
 import * as Immutable from "immutable";
-import { Dispatcher, DispatcherMessage, DispatcherBuilder } from "../dispatcher";
+import { Dispatcher, DispatcherMessage, DispatcherClass } from "../dispatcher";
 
 export type ActionHandler<TClass, TState> = (action: TClass, state: TState) => TState | void;
 
@@ -138,8 +138,8 @@ export abstract class ReduceStore<TState> extends FluxReduceStore<TState, Dispat
      * This method will return the dispatcher for this store.
      *
      */
-    public getDispatcher(): DispatcherBuilder {
-        return super.getDispatcher();
+    public getDispatcher(): DispatcherClass {
+        return super.getDispatcher() as DispatcherClass;
     }
 
     /**