[refactored] Creator to Connect and Channel to NextChannel

Summary:
As a result of our discussion on type naming.  SO EXCITED WE GET TO USE CONNECT!!!

Closes #9

Reviewers: O3 Material JavaScript platform reviewers, markwei, #material_motion, O2 Material Motion

Reviewed By: markwei, #material_motion, O2 Material Motion

Subscribers: markwei

Tags: #material_motion

Differential Revision: http://codereview.cc/D2210

Author: appsforartists

dist/IndefiniteObservable.d.ts

@@ -1,6 +1,6 @@
-import { Creator, Observable, ObserverOrNext, Subscription } from './types';
+import { Connect, Observable, ObserverOrNext, Subscription } from './types';
 export default class IndefiniteObservable<T> implements Observable<T> {
-    _creator: Creator<T>;
-    constructor(creator: Creator<T>);
+    _connect: Connect<T>;
+    constructor(connect: Connect<T>);
     subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
 }

dist/IndefiniteObservable.js

@@ -75,14 +75,14 @@ var $observable = (
 )();
 
 class IndefiniteObservable {
-    constructor(creator) {
-        this._creator = creator;
+    constructor(connect) {
+        this._connect = connect;
     }
     subscribe(observerOrNext) {
         const observer = wrapWithObserver(observerOrNext);
-        let unsubscribe = this._creator(observer);
+        const disconnect = this._connect(observer);
         return {
-            unsubscribe,
+            unsubscribe: disconnect,
         };
     }
     /**

dist/IndefiniteSubject.js

@@ -14,15 +14,16 @@
  *  under the License.
  */
 export interface Observable<T> {
-    subscribe(listener: Observer<T> | Channel<T>): Subscription;
+    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
 }
 export interface Observer<T> {
-    next: Channel<T>;
+    next: NextChannel<T>;
 }
-export declare type Creator<T> = (observer: Observer<T>) => Unsubscribe;
-export declare type Channel<T> = (value: T) => void;
-export declare type ObserverOrNext<T> = Observer<T> | Channel<T>;
+export declare type Connect<T> = (observer: Observer<T>) => Disconnect;
+export declare type Disconnect = () => void;
+export declare type NextChannel<T> = (value: T) => void;
+export declare type ObserverOrNext<T> = Observer<T> | NextChannel<T>;
 export declare type Unsubscribe = () => void;
-export interface Subscription {
+export declare type Subscription = {
     unsubscribe: Unsubscribe;
-}
+};

dist/indefinite-observable.js

@@ -19,32 +19,31 @@ import $$observable from 'symbol-observable';
 import wrapWithObserver from './wrapWithObserver';
 
 import {
-  Creator,
+  Connect,
   Observable,
   ObserverOrNext,
   Subscription,
-  Unsubscribe,
 } from './types';
 
 export default class IndefiniteObservable<T> implements Observable<T> {
-  _creator: Creator<T>;
+  _connect: Connect<T>;
 
-  constructor(creator: Creator<T>) {
-    this._creator = creator;
+  constructor(connect: Connect<T>) {
+    this._connect = connect;
   }
 
   subscribe(observerOrNext: ObserverOrNext<T>): Subscription {
-    // subscribe accepts next as either an anonymous function or as a named
-    // member on an object.  The creator always expects an object with a
-    // function named next.  Therefore, if we receive an anonymous function, we
-    // wrap it in an object literal.
+     // For simplicity's sake, `subscribe` accepts `next` either as either an
+     // anonymous function or wrapped in an object (the observer).  Since
+     // `connect` always expects to receive an observer, wrap any loose
+     // functions in an object.
 
     const observer = wrapWithObserver<T>(observerOrNext);
 
-    let unsubscribe: Unsubscribe = this._creator(observer);
+    const disconnect = this._connect(observer);
 
     return {
-      unsubscribe,
+      unsubscribe: disconnect,
     };
   }
 

dist/types.d.ts

@@ -27,7 +27,7 @@ import {
 
 export default class IndefiniteSubject<T> implements Observable<T>, Observer<T> {
   // Keep track of all the observers who have subscribed, so we can notify them
-  // when we get new values.
+  // when we get new values.  Note: JavaScript's Set collection is ordered.
   _observers: Set<Observer<T>> = new Set();
   _lastValue: T;
   _hasStarted: boolean = false;

src/IndefiniteObservable.ts

@@ -15,19 +15,20 @@
  */
 
 export interface Observable<T> {
-  subscribe(listener: Observer<T> | Channel<T>): Subscription;
+  subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
 }
 
 export interface Observer<T> {
-  next: Channel<T>,
+  next: NextChannel<T>,
 }
 
-export type Creator<T> = (observer: Observer<T>) => Unsubscribe;
+export type Connect<T> = (observer: Observer<T>) => Disconnect;
+export type Disconnect = () => void;
 
-export type Channel<T> = (value: T) => void;
-export type ObserverOrNext<T> = Observer<T> | Channel<T>;
+export type NextChannel<T> = (value: T) => void;
+export type ObserverOrNext<T> = Observer<T> | NextChannel<T>;
 
 export type Unsubscribe = () => void;
-export interface Subscription {
+export type Subscription = {
   unsubscribe: Unsubscribe,
 }

src/IndefiniteSubject.ts

@@ -15,7 +15,7 @@
  */
 
 import {
-  Channel,
+  NextChannel,
   Observer,
   ObserverOrNext,
 } from './types';
@@ -32,7 +32,7 @@ export default function wrapWithObserver<T>(listener: ObserverOrNext<T>): Observ
 
   } else {
     return {
-      next: (listener as Channel<T>)
+      next: (listener as NextChannel<T>)
     };
   }
 }