[renamed] listener to observerOrNext

Reviewers: featherless, O2 Material Motion

Reviewed By: featherless, O2 Material Motion

Tags: #material_motion

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

build.js

@@ -38,23 +38,23 @@ const licenseText = `/** @license
 
 const observableSource = readFileSync('./dist/IndefiniteObservable.js').toString();
 const subjectSource = readFileSync('./dist/IndefiniteSubject.js').toString();
-const wrapListenerWithObserverSource = readFileSync('./dist/wrapListenerWithObserver.js').toString();
+const wrapWithObserverSource = readFileSync('./dist/wrapWithObserver.js').toString();
 const symbolObservable = readFileSync('./third_party/symbol-observable/index.js').toString();
 
 writeFileSync(
   './dist/indefinite-observable.js',
   licenseText + '\n' +[
     observableSource.replace(licenseText, ''),
     subjectSource.replace(licenseText, ''),
-    wrapListenerWithObserverSource.replace(licenseText, ''),
+    wrapWithObserverSource.replace(licenseText, ''),
   ].join('\n\n').replace(
     /const symbol_observable_\d = require\("symbol-observable"\);/,
     symbolObservable
   ).replace(
     /const symbol_observable_\d = require\("symbol-observable"\);/,
     ''
   ).replace(
-    /const wrapListenerWithObserver_\d = require\(".\/wrapListenerWithObserver"\);/g,
+    /const wrapWithObserver_\d = require\(".\/wrapWithObserver"\);/g,
     ''
   ).replace(
     // strip comments
@@ -64,8 +64,8 @@ writeFileSync(
     /symbol_observable_\d\.default/g,
     '$$observable'
   ).replace(
-    /wrapListenerWithObserver_\d\.default/g,
-    'wrapListenerWithObserver'
+    /wrapWithObserver_\d\.default/g,
+    'wrapWithObserver'
   ).replace(
     /Object\.defineProperty\(exports, "__esModule", \{ value: true \}\);/g,
     ''

dist/IndefiniteObservable.d.ts

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

dist/IndefiniteSubject.d.ts

@@ -1,8 +1,8 @@
-import { Listener, Observable, Observer, Subscription } from './types';
+import { Observable, Observer, ObserverOrNext, Subscription } from './types';
 export default class IndefiniteSubject<T> implements Observable<T>, Observer<T> {
     _observers: Set<Observer<T>>;
     _lastValue: T;
     _hasStarted: boolean;
     next(value: T): void;
-    subscribe(listener: Listener<T>): Subscription;
+    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
 }

dist/indefinite-observable.js

@@ -78,8 +78,8 @@ class IndefiniteObservable {
     constructor(creator) {
         this._creator = creator;
     }
-    subscribe(listener) {
-        const observer = wrapListenerWithObserver(listener);
+    subscribe(observerOrNext) {
+        const observer = wrapWithObserver(observerOrNext);
         let unsubscribe = this._creator(observer);
         return {
             unsubscribe,
@@ -105,8 +105,8 @@ class IndefiniteSubject {
         this._lastValue = value;
         this._observers.forEach((observer) => observer.next(value));
     }
-    subscribe(listener) {
-        const observer = wrapListenerWithObserver(listener);
+    subscribe(observerOrNext) {
+        const observer = wrapWithObserver(observerOrNext);
         this._observers.add(observer);
         if (this._hasStarted) {
             observer.next(this._lastValue);
@@ -127,7 +127,7 @@ class IndefiniteSubject {
     }
 }
 
-function wrapListenerWithObserver(listener) {
+function wrapWithObserver(listener) {
     if (listener.next) {
         return listener;
     }

dist/types.d.ts

@@ -21,7 +21,7 @@ export interface Observer<T> {
 }
 export declare type Creator<T> = (observer: Observer<T>) => Unsubscribe;
 export declare type Channel<T> = (value: T) => void;
-export declare type Listener<T> = Observer<T> | Channel<T>;
+export declare type ObserverOrNext<T> = Observer<T> | Channel<T>;
 export declare type Unsubscribe = () => void;
 export interface Subscription {
     unsubscribe: Unsubscribe;

dist/wrapListenerWithObserver.d.ts → dist/wrapWithObserver.d.ts

@@ -13,5 +13,5 @@
  *  License for the specific language governing permissions and limitations
  *  under the License.
  */
-import { Observer, Listener } from './types';
-export default function wrapListenerWithObserver<T>(listener: Listener<T>): Observer<T>;
+import { Observer, ObserverOrNext } from './types';
+export default function wrapWithObserver<T>(listener: ObserverOrNext<T>): Observer<T>;

src/IndefiniteObservable.ts

@@ -16,14 +16,14 @@
 
 import $$observable from 'symbol-observable';
 
-import wrapListenerWithObserver from './wrapListenerWithObserver';
+import wrapWithObserver from './wrapWithObserver';
 
 import {
   Channel,
   Creator,
-  Listener,
   Observable,
   Observer,
+  ObserverOrNext,
   Subscription,
   Unsubscribe,
 } from './types';
@@ -35,13 +35,13 @@ export default class IndefiniteObservable<T> implements Observable<T> {
     this._creator = creator;
   }
 
-  subscribe(listener: Listener<T>): Subscription {
+  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.
 
-    const observer = wrapListenerWithObserver<T>(listener);
+    const observer = wrapWithObserver<T>(observerOrNext);
 
     let unsubscribe: Unsubscribe = this._creator(observer);
 

src/IndefiniteSubject.ts

@@ -16,13 +16,13 @@
 
 import $$observable from 'symbol-observable';
 
-import wrapListenerWithObserver from './wrapListenerWithObserver';
+import wrapWithObserver from './wrapWithObserver';
 
 import {
   Channel,
-  Listener,
   Observable,
   Observer,
+  ObserverOrNext,
   Subscription,
   Unsubscribe,
 } from './types';
@@ -46,8 +46,8 @@ export default class IndefiniteSubject<T> implements Observable<T>, Observer<T>
     );
   }
 
-  subscribe(listener: Listener<T>): Subscription {
-    const observer = wrapListenerWithObserver<T>(listener);
+  subscribe(observerOrNext: ObserverOrNext<T>): Subscription {
+    const observer = wrapWithObserver<T>(observerOrNext);
 
     this._observers.add(observer);
 

src/types.ts

@@ -25,7 +25,7 @@ export interface Observer<T> {
 export type Creator<T> = (observer: Observer<T>) => Unsubscribe;
 
 export type Channel<T> = (value: T) => void;
-export type Listener<T> = Observer<T> | Channel<T>;
+export type ObserverOrNext<T> = Observer<T> | Channel<T>;
 
 export type Unsubscribe = () => void;
 export interface Subscription {

src/wrapListenerWithObserver.ts → src/wrapWithObserver.ts

@@ -19,17 +19,18 @@ import {
   Observer,
   Creator,
   Channel,
-  Listener,
+  ObserverOrNext,
   Unsubscribe,
   Subscription,
 } from './types';
 
 // TypeScript is a pain to use with polymorphic types unless you wrap them in a
 // function that returns a single type.  So, that's what this is.
 //
-// If you give it an observer, you get back that observer.  If you give it a
-// lambda, you get back that lambda wrapped in an observer.
-export default function wrapListenerWithObserver<T>(listener: Listener<T>): Observer<T> {
+// If you give it an observer, you get back that observer.  If you give it an
+// anonymous function, you get back that anonymous function wrapped in an
+// observer.
+export default function wrapWithObserver<T>(listener: ObserverOrNext<T>): Observer<T> {
   if ((listener as Observer<T>).next) {
     return (listener as Observer<T>);