BREAKING CHANGE(scope): switch to @pushrocks scope

ts/index.ts

@@ -1,11 +1,9 @@
-import * as plugins from './smartrx.plugins'
+import * as plugins from './smartrx.plugins';
 
-export let standardExport = 'Hi there! :) This is a exported string'
-export * from './smartrx.classes.observablemap'
-export * from './smartrx.classes.observableintake'
+export let standardExport = 'Hi there! :) This is a exported string';
+export * from './smartrx.classes.observablemap';
+export * from './smartrx.classes.observableintake';
 
-import * as rxjs from 'rxjs'
+import * as rxjs from 'rxjs';
 
-export {
-  rxjs
-}
+export { rxjs };

ts/smartrx.classes.observableintake.ts

@@ -1,49 +1,49 @@
-import * as plugins from './smartrx.plugins'
-import { Observable, Subscription } from 'rxjs'
-import { Deferred } from 'smartq'
+import * as plugins from './smartrx.plugins';
+import { Observable, Subscription } from 'rxjs';
+import { Deferred } from 'smartq';
 
 /**
  * ObservableIntake
  */
 export class ObservableIntake<T> {
-  observable: Observable<T>
-  completed: Promise<void>
-  private completedDeffered: Deferred<void>
+  observable: Observable<T>;
+  completed: Promise<void>;
+  private completedDeffered: Deferred<void>;
   private observableFunctions: any = {
-    next: (payloadArg) => {
+    next: payloadArg => {
       // nothing
     },
-    complete: (payloadArg) => {
+    complete: payloadArg => {
       // nothing
     }
-  }
-  private generator = null
-  private buffered = false
-  private payloadBuffer = []
+  };
+  private generator = null;
+  private buffered = false;
+  private payloadBuffer = [];
 
-  constructor () {
-    this.observable = Observable.create((observerArg) => {
+  constructor() {
+    this.observable = Observable.create(observerArg => {
       this.observableFunctions.next = (...args) => {
-        return observerArg.next(...args)
-      }
+        return observerArg.next(...args);
+      };
       this.observableFunctions.complete = (...args) => {
-        this.completedDeffered.resolve()
-        return observerArg.complete(...args)
-      }
-    })
-    this.completedDeffered = plugins.smartq.defer()
-    this.completed = this.completedDeffered.promise
+        this.completedDeffered.resolve();
+        return observerArg.complete(...args);
+      };
+    });
+    this.completedDeffered = plugins.smartpromise.defer();
+    this.completed = this.completedDeffered.promise;
   }
 
-  setObservable (observableFunc) {
-    this.observable = observableFunc()
+  setObservable(observableFunc) {
+    this.observable = observableFunc();
   }
 
-  push (payloadArg: T) {
+  push(payloadArg: T) {
     if (this.buffered) {
-      this.payloadBuffer.push(payloadArg)
+      this.payloadBuffer.push(payloadArg);
     } else {
-      this.internalPush(payloadArg)
+      this.internalPush(payloadArg);
     }
   }
 
@@ -51,9 +51,9 @@ export class ObservableIntake<T> {
    * pushes many payloads as array
    * @param payloadArgArray
    */
-  pushMany (payloadArgArray: T[]) {
+  pushMany(payloadArgArray: T[]) {
     for (let item of payloadArgArray) {
-      this.push(item)
+      this.push(item);
     }
   }
 
@@ -61,32 +61,32 @@ export class ObservableIntake<T> {
    * sets a generator to query the next pushed value
    * @param generatorArg
    */
-  setGenerator (generatorArg) {
-    this.generator = generatorArg
+  setGenerator(generatorArg) {
+    this.generator = generatorArg;
   }
 
   makeBuffered() {
-    this.buffered = true
+    this.buffered = true;
   }
 
-  subscribe (...args) {
-    return this.observable.subscribe(...args)
+  subscribe(...args) {
+    return this.observable.subscribe(...args);
   }
 
   /**
    * request the next values in the quantity specified
    * @param howManyArg if a generator is set, of a buffer exists, this allows retrieving values
    */
-  request (howManyArg: number) {
+  request(howManyArg: number) {
     if (howManyArg === 0) {
-      return
+      return;
     } else {
       for (let i = 0; i !== howManyArg; i++) {
         if (this.payloadBuffer.length > 0) {
-          this.internalPush(this.payloadBuffer.shift())
+          this.internalPush(this.payloadBuffer.shift());
         } else {
-          const nextPayload = this.generator()
-          this.internalPush(nextPayload)
+          const nextPayload = this.generator();
+          this.internalPush(nextPayload);
         }
       }
     }
@@ -95,11 +95,11 @@ export class ObservableIntake<T> {
   /**
    * signals the completion of this observable
    */
-  signalComplete () {
-    this.observableFunctions.complete()
+  signalComplete() {
+    this.observableFunctions.complete();
   }
 
-  private internalPush (payloadArg) {
-    this.observableFunctions.next(payloadArg)
+  private internalPush(payloadArg) {
+    this.observableFunctions.next(payloadArg);
   }
 }

ts/smartrx.classes.observablemap.ts

@@ -1,41 +1,39 @@
-import * as plugins from './smartrx.plugins'
-import { Observable } from 'rxjs'
-import { Objectmap } from 'lik'
-import { Stringmap } from 'lik'
-
+import * as plugins from './smartrx.plugins';
+import { Observable, fromEvent } from 'rxjs';
+import { Objectmap, Stringmap } from '@pushrocks/lik';
 /**
  * bundles an observable with an emitter
  */
 export interface ObservableEmitterBundle {
-  observable: plugins.rxjs.Observable<any>
-  emitter: plugins.events.EventEmitter
-  event: string
+  observable: plugins.rxjs.Observable<any>;
+  emitter: plugins.events.EventEmitter;
+  event: string;
 }
 
 /**
  * manages observables by making sure that only one observable is regsitered per event
  */
 export class Observablemap {
-  ObservableEmitterBundleObjectmap = new Objectmap<ObservableEmitterBundle>()
+  ObservableEmitterBundleObjectmap = new Objectmap<ObservableEmitterBundle>();
 
   /**
    * creates a new observable if not yet registered for the same event.
    * In case event has been registered before the same observable is returned.
    */
-  getObservableForEmitterEvent (emitterArg: plugins.events.EventEmitter, eventArg: string) {
-    let existingBundle = this.ObservableEmitterBundleObjectmap.find((bundleArg) => {
-      return (bundleArg.emitter === emitterArg && bundleArg.event === eventArg)
-    })
+  getObservableForEmitterEvent(emitterArg: plugins.events.EventEmitter, eventArg: string) {
+    let existingBundle = this.ObservableEmitterBundleObjectmap.find(bundleArg => {
+      return bundleArg.emitter === emitterArg && bundleArg.event === eventArg;
+    });
     if (existingBundle) {
-      return existingBundle.observable
+      return existingBundle.observable;
     } else {
-      let emitterObservable = plugins.rxjs.Observable.fromEvent(emitterArg, eventArg)
+      let emitterObservable = fromEvent(emitterArg, eventArg);
       this.ObservableEmitterBundleObjectmap.add({
         observable: emitterObservable,
         emitter: emitterArg,
         event: eventArg
-      })
-      return emitterObservable
+      });
+      return emitterObservable;
     }
   }
 }

ts/smartrx.plugins.ts

@@ -1,15 +1,7 @@
-import 'typings-global'
-import * as events from 'events'
-import * as lik from 'lik'
-import * as rxjs from 'rxjs'
-import * as smartevent from 'smartevent'
-import * as smartq from 'smartq'
-import 'typings-global'
+import * as events from 'events';
+import * as lik from '@pushrocks/lik';
+import * as rxjs from 'rxjs';
+import * as smartevent from 'smartevent';
+import * as smartpromise from '@pushrocks/smartpromise';
 
-export {
-  events,
-  lik,
-  rxjs,
-  smartevent,
-  smartq
-}
+export { events, lik, rxjs, smartevent, smartpromise };