fix(typings): make an exported function's destructuring signature explicitly.

tetsuharuohzeki · benlesh · commit ef305af977ec · 2016-04-12T13:33:58.000-07:00
diff --git a/src/observable/BoundCallbackObservable.ts b/src/observable/BoundCallbackObservable.ts
@@ -138,11 +138,21 @@ function dispatch<T>(state: { source: BoundCallbackObservable<T>, subscriber: Su
   self.add(subject.subscribe(subscriber));
 }
 
-function dispatchNext({ value, subject }) {
+interface DispatchNextArg<T> {
+  subject: AsyncSubject<T>;
+  value: T;
+}
+function dispatchNext<T>(arg: DispatchNextArg<T>) {
+  const { value, subject } = arg;
   subject.next(value);
   subject.complete();
 }
 
-function dispatchError({ err, subject }) {
+interface DispatchErrorArg<T> {
+  subject: AsyncSubject<T>;
+  err: any;
+}
+function dispatchError<T>(arg: DispatchErrorArg<T>) {
+  const { err, subject } = arg;
   subject.error(err);
 }
diff --git a/src/observable/BoundNodeCallbackObservable.ts b/src/observable/BoundNodeCallbackObservable.ts
@@ -135,11 +135,21 @@ function dispatch<T>(state: { source: BoundNodeCallbackObservable<T>, subscriber
   self.add(subject.subscribe(subscriber));
 }
 
-function dispatchNext({ value, subject }) {
+interface DispatchNextArg<T> {
+  subject: AsyncSubject<T>;
+  value: T;
+}
+function dispatchNext<T>(arg: DispatchNextArg<T>) {
+  const { value, subject } = arg;
   subject.next(value);
   subject.complete();
 }
 
-function dispatchError({ err, subject }) {
+interface DispatchErrorArg<T> {
+  subject: AsyncSubject<T>;
+  err: any;
+}
+function dispatchError<T>(arg: DispatchErrorArg<T>) {
+  const { err, subject } = arg;
   subject.error(err);
 }
diff --git a/src/observable/EmptyObservable.ts b/src/observable/EmptyObservable.ts
@@ -3,6 +3,10 @@ import {Subscriber} from '../Subscriber';
 import {Observable} from '../Observable';
 import {TeardownLogic} from '../Subscription';
 
+export interface DispatchArg<T> {
+  subscriber: Subscriber<T>;
+}
+
 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @extends {Ignored}
@@ -51,7 +55,8 @@ export class EmptyObservable<T> extends Observable<T> {
     return new EmptyObservable<T>(scheduler);
   }
 
-  static dispatch({ subscriber }) {
+  static dispatch<T>(arg: DispatchArg<T>) {
+    const { subscriber } = arg;
     subscriber.complete();
   }
 
diff --git a/src/observable/ErrorObservable.ts b/src/observable/ErrorObservable.ts
@@ -2,6 +2,11 @@ import {Scheduler} from '../Scheduler';
 import {Observable} from '../Observable';
 import {TeardownLogic} from '../Subscription';
 
+export interface DispatchArg {
+  error: any;
+  subscriber: any;
+}
+
 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @extends {Ignored}
@@ -53,7 +58,8 @@ export class ErrorObservable extends Observable<any> {
     return new ErrorObservable(error, scheduler);
   }
 
-  static dispatch({ error, subscriber }) {
+  static dispatch(arg: DispatchArg) {
+    const { error, subscriber } = arg;
     subscriber.error(error);
   }
 
diff --git a/src/observable/PromiseObservable.ts b/src/observable/PromiseObservable.ts
@@ -88,14 +88,24 @@ export class PromiseObservable<T> extends Observable<T> {
   }
 }
 
-function dispatchNext({ value, subscriber }) {
+interface DispatchNextArg<T> {
+  subscriber: Subscriber<T>;
+  value: T;
+}
+function dispatchNext<T>(arg: DispatchNextArg<T>) {
+  const { value, subscriber } = arg;
   if (!subscriber.isUnsubscribed) {
     subscriber.next(value);
     subscriber.complete();
   }
 }
 
-function dispatchError({ err, subscriber }) {
+interface DispatchErrorArg<T> {
+  subscriber: Subscriber<T>;
+  err: any;
+}
+function dispatchError<T>(arg: DispatchErrorArg<T>) {
+  const { err, subscriber } = arg;
   if (!subscriber.isUnsubscribed) {
     subscriber.error(err);
   }
diff --git a/src/observable/SubscribeOnObservable.ts b/src/observable/SubscribeOnObservable.ts
@@ -5,6 +5,11 @@ import {Observable} from '../Observable';
 import {asap} from '../scheduler/asap';
 import {isNumeric} from '../util/isNumeric';
 
+export interface DispatchArg<T> {
+  source: Observable<T>;
+  subscriber: Subscriber<T>;
+}
+
 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @extends {Ignored}
@@ -15,7 +20,8 @@ export class SubscribeOnObservable<T> extends Observable<T> {
     return new SubscribeOnObservable(source, delay, scheduler);
   }
 
-  static dispatch<T>({ source, subscriber }): Subscription {
+  static dispatch<T>(arg: DispatchArg<T>): Subscription {
+    const { source, subscriber } = arg;
     return source.subscribe(subscriber);
   }
 
diff --git a/src/operator/bufferTime.ts b/src/operator/bufferTime.ts
@@ -152,16 +152,22 @@ function dispatchBufferTimeSpanOnly(state: any) {
   }
 }
 
+interface DispatchArg<T> {
+  subscriber: BufferTimeSubscriber<T>;
+  buffer: Array<T>;
+}
+
 function dispatchBufferCreation<T>(state: CreationState<T>) {
   const { bufferCreationInterval, bufferTimeSpan, subscriber, scheduler } = state;
   const buffer = subscriber.openBuffer();
   const action = <Action<CreationState<T>>>this;
   if (!subscriber.isUnsubscribed) {
-    action.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, { subscriber, buffer }));
+    action.add(scheduler.schedule<DispatchArg<T>>(dispatchBufferClose, bufferTimeSpan, { subscriber, buffer }));
     action.schedule(state, bufferCreationInterval);
   }
 }
 
-function dispatchBufferClose({ subscriber, buffer }) {
+function dispatchBufferClose<T>(arg: DispatchArg<T>) {
+  const { subscriber, buffer } = arg;
   subscriber.closeBuffer(buffer);
 }
diff --git a/src/operator/expand.ts b/src/operator/expand.ts
@@ -43,6 +43,13 @@ export class ExpandOperator<T, R> implements Operator<T, R> {
   }
 }
 
+interface DispatchArg<T, R> {
+  subscriber: ExpandSubscriber<T, R>;
+  result: Observable<R>;
+  value: any;
+  index: number;
+}
+
 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @ignore
@@ -64,7 +71,8 @@ export class ExpandSubscriber<T, R> extends OuterSubscriber<T, R> {
     }
   }
 
-  private static dispatch({subscriber, result, value, index}): void {
+  private static dispatch<T, R>(arg: DispatchArg<T, R>): void {
+    const {subscriber, result, value, index} = arg;
     subscriber.subscribeToProjection(result, value, index);
   }
 
@@ -85,7 +93,7 @@ export class ExpandSubscriber<T, R> extends OuterSubscriber<T, R> {
       } else if (!this.scheduler) {
         this.subscribeToProjection(result, value, index);
       } else {
-        const state = { subscriber: this, result, value, index };
+        const state: DispatchArg<T, R> = { subscriber: this, result, value, index };
         this.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state));
       }
     } else {
diff --git a/src/operator/observeOn.ts b/src/operator/observeOn.ts
@@ -37,7 +37,8 @@ export class ObserveOnOperator<T> implements Operator<T, T> {
  * @extends {Ignored}
  */
 export class ObserveOnSubscriber<T> extends Subscriber<T> {
-  static dispatch({ notification, destination }) {
+  static dispatch(arg: ObserveOnMessage) {
+    const { notification, destination } = arg;
     notification.observe(destination);
   }
 
@@ -66,7 +67,7 @@ export class ObserveOnSubscriber<T> extends Subscriber<T> {
   }
 }
 
-class ObserveOnMessage {
+export class ObserveOnMessage {
   constructor(public notification: Notification<any>,
               public destination: PartialObserver<any>) {
   }
diff --git a/src/operator/throttleTime.ts b/src/operator/throttleTime.ts
@@ -60,6 +60,11 @@ class ThrottleTimeSubscriber<T> extends Subscriber<T> {
   }
 }
 
-function dispatchNext<T>({ subscriber }) {
+interface DispatchArg<T> {
+  subscriber: ThrottleTimeSubscriber<T>;
+}
+
+function dispatchNext<T>(arg: DispatchArg<T>) {
+  const { subscriber } = arg;
   subscriber.clearThrottle();
 }
diff --git a/src/operator/windowTime.ts b/src/operator/windowTime.ts
@@ -2,6 +2,7 @@ import {Operator} from '../Operator';
 import {Subscriber} from '../Subscriber';
 import {Observable} from '../Observable';
 import {Subject} from '../Subject';
+import {Subscription} from '../Subscription';
 import {Scheduler} from '../Scheduler';
 import {Action} from '../scheduler/Action';
 import {async} from '../scheduler/async';
@@ -79,12 +80,12 @@ class WindowTimeOperator<T> implements Operator<T, Observable<T>> {
   }
 }
 
-type CreationState<T> = {
+interface CreationState<T> {
   windowTimeSpan: number;
   windowCreationInterval: number;
   subscriber: WindowTimeSubscriber<T>;
   scheduler: Scheduler;
-};
+}
 
 /**
  * We need this JSDoc comment for affecting ESDoc.
@@ -173,18 +174,30 @@ function dispatchWindowTimeSpanOnly<T>(state: TimeSpanOnlyState<T>) {
   (<any>this).schedule(state, windowTimeSpan);
 }
 
+interface Context<T> {
+  action: Action<CreationState<T>>;
+  subscription: Subscription;
+}
+
+interface DispatchArg<T> {
+  subscriber: WindowTimeSubscriber<T>;
+  window: Subject<T>;
+  context: Context<T>;
+}
+
 function dispatchWindowCreation<T>(state: CreationState<T>) {
   let { windowTimeSpan, subscriber, scheduler, windowCreationInterval } = state;
   let window = subscriber.openWindow();
   let action = <Action<CreationState<T>>>this;
-  let context = { action, subscription: <any>null };
-  const timeSpanState = { subscriber, window, context };
+  let context: Context<T> = { action, subscription: <any>null };
+  const timeSpanState: DispatchArg<T> = { subscriber, window, context };
   context.subscription = scheduler.schedule(dispatchWindowClose, windowTimeSpan, timeSpanState);
   action.add(context.subscription);
   action.schedule(state, windowCreationInterval);
 }
 
-function dispatchWindowClose({ subscriber, window, context }) {
+function dispatchWindowClose<T>(arg: DispatchArg<T>) {
+  const { subscriber, window, context } = arg;
   if (context && context.action && context.subscription) {
     context.action.remove(context.subscription);
   }

Original file line number	Diff line number	Diff line change
`@@ -88,14 +88,24 @@ export class PromiseObservable<T> extends Observable<T> {`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`-function dispatchNext({ value, subscriber }) {`
	`91`	`+interface DispatchNextArg<T> {`
	`92`	`+ subscriber: Subscriber<T>;`
	`93`	`+ value: T;`
	`94`	`+}`
	`95`	`+function dispatchNext<T>(arg: DispatchNextArg<T>) {`
	`96`	`+ const { value, subscriber } = arg;`
`92`	`97`	`if (!subscriber.isUnsubscribed) {`
`93`	`98`	`subscriber.next(value);`
`94`	`99`	`subscriber.complete();`
`95`	`100`	`}`
`96`	`101`	`}`
`97`	`102`
`98`		`-function dispatchError({ err, subscriber }) {`
	`103`	`+interface DispatchErrorArg<T> {`
	`104`	`+ subscriber: Subscriber<T>;`
	`105`	`+ err: any;`
	`106`	`+}`
	`107`	`+function dispatchError<T>(arg: DispatchErrorArg<T>) {`
	`108`	`+ const { err, subscriber } = arg;`
`99`	`109`	`if (!subscriber.isUnsubscribed) {`
`100`	`110`	`subscriber.error(err);`
`101`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,16 +152,22 @@ function dispatchBufferTimeSpanOnly(state: any) {`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
	`155`	`+interface DispatchArg<T> {`
	`156`	`+ subscriber: BufferTimeSubscriber<T>;`
	`157`	`+ buffer: Array<T>;`
	`158`	`+}`
	`159`	`+`
`155`	`160`	`function dispatchBufferCreation<T>(state: CreationState<T>) {`
`156`	`161`	`const { bufferCreationInterval, bufferTimeSpan, subscriber, scheduler } = state;`
`157`	`162`	`const buffer = subscriber.openBuffer();`
`158`	`163`	`const action = <Action<CreationState<T>>>this;`
`159`	`164`	`if (!subscriber.isUnsubscribed) {`
`160`		`- action.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, { subscriber, buffer }));`
	`165`	`+ action.add(scheduler.schedule<DispatchArg<T>>(dispatchBufferClose, bufferTimeSpan, { subscriber, buffer }));`
`161`	`166`	`action.schedule(state, bufferCreationInterval);`
`162`	`167`	`}`
`163`	`168`	`}`
`164`	`169`
`165`		`-function dispatchBufferClose({ subscriber, buffer }) {`
	`170`	`+function dispatchBufferClose<T>(arg: DispatchArg<T>) {`
	`171`	`+ const { subscriber, buffer } = arg;`
`166`	`172`	`subscriber.closeBuffer(buffer);`
`167`	`173`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,13 @@ export class ExpandOperator<T, R> implements Operator<T, R> {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
	`46`	`+interface DispatchArg<T, R> {`
	`47`	`+ subscriber: ExpandSubscriber<T, R>;`
	`48`	`+ result: Observable<R>;`
	`49`	`+ value: any;`
	`50`	`+ index: number;`
	`51`	`+}`
	`52`	`+`
`46`	`53`	`/**`
`47`	`54`	`* We need this JSDoc comment for affecting ESDoc.`
`48`	`55`	`* @ignore`
`@@ -64,7 +71,8 @@ export class ExpandSubscriber<T, R> extends OuterSubscriber<T, R> {`
`64`	`71`	`}`
`65`	`72`	`}`
`66`	`73`
`67`		`- private static dispatch({subscriber, result, value, index}): void {`
	`74`	`+ private static dispatch<T, R>(arg: DispatchArg<T, R>): void {`
	`75`	`+ const {subscriber, result, value, index} = arg;`
`68`	`76`	`subscriber.subscribeToProjection(result, value, index);`
`69`	`77`	`}`
`70`	`78`
`@@ -85,7 +93,7 @@ export class ExpandSubscriber<T, R> extends OuterSubscriber<T, R> {`
`85`	`93`	`} else if (!this.scheduler) {`
`86`	`94`	`this.subscribeToProjection(result, value, index);`
`87`	`95`	`} else {`
`88`		`- const state = { subscriber: this, result, value, index };`
	`96`	`+ const state: DispatchArg<T, R> = { subscriber: this, result, value, index };`
`89`	`97`	`this.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state));`
`90`	`98`	`}`
`91`	`99`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,8 @@ export class ObserveOnOperator<T> implements Operator<T, T> {`
`37`	`37`	`* @extends {Ignored}`
`38`	`38`	`*/`
`39`	`39`	`export class ObserveOnSubscriber<T> extends Subscriber<T> {`
`40`		`- static dispatch({ notification, destination }) {`
	`40`	`+ static dispatch(arg: ObserveOnMessage) {`
	`41`	`+ const { notification, destination } = arg;`
`41`	`42`	`notification.observe(destination);`
`42`	`43`	`}`
`43`	`44`
`@@ -66,7 +67,7 @@ export class ObserveOnSubscriber<T> extends Subscriber<T> {`
`66`	`67`	`}`
`67`	`68`	`}`
`68`	`69`
`69`		`-class ObserveOnMessage {`
	`70`	`+export class ObserveOnMessage {`
`70`	`71`	`constructor(public notification: Notification<any>,`
`71`	`72`	`public destination: PartialObserver<any>) {`
`72`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,11 @@ class ThrottleTimeSubscriber<T> extends Subscriber<T> {`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`-function dispatchNext<T>({ subscriber }) {`
	`63`	`+interface DispatchArg<T> {`
	`64`	`+ subscriber: ThrottleTimeSubscriber<T>;`
	`65`	`+}`
	`66`	`+`
	`67`	`+function dispatchNext<T>(arg: DispatchArg<T>) {`
	`68`	`+ const { subscriber } = arg;`
`64`	`69`	`subscriber.clearThrottle();`
`65`	`70`	`}`