Merge pull request #848 from david-driscoll/master

Rewrite typescript declarations

Author: mattpodwysocki

Gruntfile.js

@@ -2541,6 +2541,156 @@ module.exports = function (grunt) {
     'nuget-time',
     'nuget-virtualtime'
   ]);
+  
+  
+
+  grunt.registerTask('rebuild-ts', 'Rebuild typescript declarations', function() {
+    var path = require('path');
+    var fs = require('fs');
+
+    var cache = {};
+    var dependencies = {};
+    var concatItems = grunt.config.get('concat');
+
+    function loadFile(tsFile) {
+      if (cache[tsFile]) {
+        return;
+      }
+      var dependencyRegex = /\/\/\/ <reference path\=\"(.*?)\" \/>/g;
+      var c; //, count = 0;
+      var source = grunt.file.read(tsFile);
+
+      // source with tests
+      var s = source.match(/module Rx \{([\s\S]*)\}[\s\S]*\(function/);
+      if (s && s[1]) {
+        c = cache[tsFile] = s[1];
+	  }
+	  if (!s) {
+	    // source without tests
+		s = source.match(/module Rx \{([\s\S]*)\}/);
+		if (s && s[1]) {
+		  c = cache[tsFile] = s[1];
+		}
+	  }
+
+	  var deps = dependencies[tsFile] = [];
+	  var result;
+	  while (result = dependencyRegex.exec(source)) {
+		var dep = path.resolve(__dirname, path.dirname(tsFile), result[1])
+		  .substr(__dirname.length + 1)
+		  .replace(/\\/g, '/');
+
+		deps.push(dep);
+		loadFile(dep);
+	  }
+
+	  return c;
+	}
+
+    function addLoadedFile(tsFile) {
+      if (loadedFiles[tsFile]) {
+	    return;
+      }
+
+  	  if (!(tsFile.match(/\/toset\.ts$/) || tsFile.match(/\/tomap\.ts$/))) {
+  	    output.push(cache[tsFile]);
+	  }
+	  es6Output.push(cache[tsFile]);
+	  loadedFiles[tsFile] = true;
+    }
+
+	function addFileContent(tsFile) {
+      if (loadedFiles[tsFile]) {
+	    return;
+	  }
+
+	  var deps = dependencies[tsFile];
+	  for (var k = 0; k < deps.length; k++) {
+		addLoadedFile(deps[k]);
+		addFileContent(deps[k]);
+	  }
+
+	  addLoadedFile(tsFile);
+	}
+
+	loadFile('ts/core/es5.ts');
+	loadFile('ts/core/es6.ts');
+
+	for (var key in concatItems) {
+	  var loadedFiles = {};
+	  var output = [];
+	  var es6Output = [];
+	  var value = concatItems[key];
+	  var src = value.src;
+	  var dest = value.dest;
+
+	  var dist = false;
+
+	  if (key.indexOf('-compat') > -1) {
+	    continue;
+	  }
+
+	  if (dest.indexOf('dist/') === 0) {
+	    dist = dest.match(/dist\/(.*?)\.js/)[1];
+	    dest = dest.replace(/dist\/(.*?)\.js/, 'ts/$1.d.ts');
+	  } else if (dest.indexOf('modules/') === 0) {
+	    continue;
+	  } else {
+	    throw new Error("not sure how to handle " + dest);
+	  }
+
+	  for (var i = 0; i < src.length; i++) {
+	    var file = src[i];
+	    var tsFile = file
+	      .replace(/src\/(.*?).js/, 'ts/$1.ts')
+	      // Is this right 100% of the time?
+	      .replace('perf/operators', 'linq/observable');
+
+	    if (cache[tsFile] || fs.existsSync(tsFile)) {
+	      if (!cache[tsFile]) {
+	        loadFile(tsFile);
+	      }
+
+	      if (tsFile.indexOf('/es5') === -1 || tsFile.indexOf('/es6') === -1) {
+	        addFileContent(tsFile);
+	      }
+	    } else {
+	      var valid = ['/headers/', '/longstacktraces/', '/internal/', '/autodetachobserver', '/subjects/innersubscription', '/perf/observablebase', 'linq/enumerable/while', '.compat.', 'linq/observable/_', '/linq/observable/fromarrayobservable', '/joins/', '/linq/observable/flatmapbase', '/disposables/scheduleddisposable', '/concurrency/catchscheduler', '/core/observeonobserver', '/testing/mockpromise', '/testing/hotobservable', '/testing/coldobservable'];
+	      var validResult = false;
+	      for (var z = 0; z < valid.length; z++) {
+	        if (tsFile.indexOf(valid[z]) !== -1) {
+	          validResult = true;
+	          break;
+	        }
+	      }
+
+	      if (!validResult) {
+	        console.log('missing file: ' + tsFile);
+	      }
+	    }
+	  }
+
+      output.unshift(cache['ts/core/es5.ts']);
+      es6Output.unshift(cache['ts/core/es6.ts']);
+
+      var outputString = 'declare module Rx {\n' + output.join('') + '\n}\n';
+      outputString += '\ndeclare module "rx" { export = Rx; }\n';
+      if (dist) {
+        outputString += 'declare module "'+dist+'" { export = Rx; }';
+      }
+      grunt.file.write(dest, outputString);
+
+      outputString = 'declare module Rx {\n' + es6Output.join('') + '\n}\n';
+      outputString += '\ndeclare module "rx" { export = Rx; }\n';
+      if (dist) {
+        outputString += '\ndeclare module "'+dist+'" { export = Rx; }\n';
+      }
+      grunt.file.write(dest.replace(/^ts\//, 'ts/es6/'), outputString);
+    }
+
+    grunt.file.write('ts/es6/es6-iterable.d.ts', grunt.file.read('ts/core/es6-iterable.d.ts'));
+    grunt.file.write('ts/es6/es6-promise.d.ts', grunt.file.read('ts/core/es6-promise.d.ts'));  
+  });
 
   grunt.registerTask('concat-min', [
     'concat:core',
@@ -2633,7 +2783,7 @@ module.exports = function (grunt) {
     'copy:lite-extras-compat',
     'copy:core',
     'copy:core-binding',
-    'copy:core-testing',
+    'copy:core-testing'
   ]);
 
   // Default task
@@ -2730,6 +2880,7 @@ module.exports = function (grunt) {
     'copy:core-binding',
     'copy:core-testing',
 
-    'qunit'
+    'qunit',
+	'rebuild-ts'
   ]);
 };

ts/core/abstractobserver.ts

@@ -0,0 +1,53 @@
+/// <reference path="./disposables/disposable.ts" />
+/// <reference path="./observer-lite.ts" />
+module Rx {
+    export module internals {
+        /**
+        * Abstract base class for implementations of the Observer class.
+        * This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages.
+        */
+        export interface AbstractObserver<T> extends Rx.IObserver<T>, Rx.IDisposable {
+            /**
+            * Notifies the observer of a new element in the sequence.
+            * @param {Any} value Next element in the sequence.
+            */
+            onNext(value: T): void;
+            /**
+            * Notifies the observer that an exception has occurred.
+            * @param {Any} error The error that has occurred.
+            */
+            onError(exception: any): void;
+            /**
+            * Notifies the observer of the end of the sequence.
+            */
+            onCompleted(): void;
+
+            isStopped: boolean;
+
+            /**
+            * Disposes the observer, causing it to transition to the stopped state.
+            */
+            dispose(): void;
+
+            fail(e: any): boolean;
+
+            // Must be implemented by other observers
+            next(value: T): void;
+            error(error: any): void;
+            completed(): void;
+        }
+
+        interface AbstractObserverStatic {
+            new <T>(): AbstractObserver<T>;
+        }
+
+        export var AbstractObserver: AbstractObserverStatic
+    }
+}
+
+(function() {
+    var iObserver: Rx.IObserver<number>;
+    var abstractObserver: Rx.internals.AbstractObserver<number>;
+
+    iObserver = abstractObserver;
+});

ts/core/anonymousobservable.ts

@@ -0,0 +1,11 @@
+/// <reference path="./observable.ts" />
+module Rx {
+    export interface AnonymousObservable<T> extends Observable<T> { }
+}
+
+(function() {
+    var observable: Rx.Observable<number>;
+    var anonymousObservable: Rx.AnonymousObservable<number>;
+
+    observable = anonymousObservable;
+});

ts/core/anonymousobserver.ts

@@ -0,0 +1,42 @@
+/// <reference path="./observer-lite.ts" />
+module Rx {
+    /**
+     * Class to create an Observer instance from delegate-based implementations of the on* methods.
+     */
+    export interface AnonymousObserver<T> extends Observer<T> {
+        /**
+        * Notifies the observer of a new element in the sequence.
+        * @param {Any} value Next element in the sequence.
+        */
+        onNext(value: T): void;
+        /**
+        * Notifies the observer that an exception has occurred.
+        * @param {Any} error The error that has occurred.
+        */
+        onError(exception: any): void;
+        /**
+        * Notifies the observer of the end of the sequence.
+        */
+        onCompleted(): void;
+    }
+
+    interface AnonymousObserverStatic {
+        /**
+         * Creates an observer from the specified OnNext, OnError, and OnCompleted actions.
+         * @param {Any} onNext Observer's OnNext action implementation.
+         * @param {Any} onError Observer's OnError action implementation.
+         * @param {Any} onCompleted Observer's OnCompleted action implementation.
+         */
+        new <T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): AnonymousObserver<T>;
+    }
+
+    export var AnonymousObserver : AnonymousObserverStatic;
+}
+
+
+(function() {
+    var iObserver: Rx.IObserver<number>;
+    var anonymousObserver: Rx.AnonymousObserver<number>;
+
+    iObserver = anonymousObserver;
+});

ts/core/backpressure/controlled.ts

@@ -0,0 +1,29 @@
+/// <reference path="../disposables/disposable.ts" />
+/// <reference path="../concurrency/scheduler.ts" />
+module Rx {
+    export interface Observable<T> {
+        /**
+        * Attaches a controller to the observable sequence with the ability to queue.
+        * @example
+        * var source = Rx.Observable.interval(100).controlled();
+        * source.request(3); // Reads 3 values
+        * @param {bool} enableQueue truthy value to determine if values should be queued pending the next request
+        * @param {Scheduler} scheduler determines how the requests will be scheduled
+        * @returns {Observable} The observable sequence which only propagates values on request.
+        */
+        controlled(enableQueue?: boolean, scheduler?: IScheduler): ControlledObservable<T>;
+    }
+
+    export interface ControlledObservable<T> extends Observable<T> {
+        request(numberOfItems?: number): IDisposable;
+    }
+}
+
+(function() {
+    var o: Rx.Observable<string>;
+    var c = o.controlled();
+
+    var d: Rx.IDisposable = c.request();
+    d = c.request();
+    d = c.request(5);
+});

ts/core/backpressure/pausable.ts

@@ -0,0 +1,29 @@
+/// <reference path="../concurrency/scheduler.ts" />
+module Rx {
+    export interface Observable<T> {
+        /**
+         * Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
+         * @example
+         * var pauser = new Rx.Subject();
+         * var source = Rx.Observable.interval(100).pausable(pauser);
+         * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
+         * @returns {Observable} The observable sequence which is paused based upon the pauser.
+         */
+        pausable(pauser?: Observable<boolean>): PausableObservable<T>;
+    }
+
+    export interface PausableObservable<T> extends Observable<T> {
+        pause(): void;
+        resume(): void;
+    }
+}
+
+(function() {
+    var o: Rx.Observable<string>;
+    var b: Rx.Observable<boolean>;
+    var c = o.pausable();
+    var c = o.pausable(b);
+
+    c.pause();
+    c.resume();
+})

ts/core/backpressure/pausablebuffered.ts

@@ -0,0 +1,22 @@
+/// <reference path="./pausable.ts" />
+module Rx {
+    export interface Observable<T> {
+        /**
+         * Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
+         * and yields the values that were buffered while paused.
+         * @example
+         * var pauser = new Rx.Subject();
+         * var source = Rx.Observable.interval(100).pausableBuffered(pauser);
+         * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
+         * @returns {Observable} The observable sequence which is paused based upon the pauser.
+         */
+        pausableBuffered(pauser?: Observable<boolean>): PausableObservable<T>;
+    }
+}
+
+(function() {
+    var o: Rx.Observable<string>;
+    var b: Rx.Observable<boolean>;
+    var c = o.pausableBuffered();
+    var c = o.pausableBuffered(b);
+})

ts/core/backpressure/pauser.ts

@@ -0,0 +1,23 @@
+module Rx {
+    /**
+    * Used to pause and resume streams.
+    */
+    export interface Pauser {
+        /**
+         * Pauses the underlying sequence.
+         */
+        pause(): void;
+
+        /**
+        * Resumes the underlying sequence.
+        */
+        resume(): void;
+    }
+}
+
+(function() {
+    var p: Rx.Pauser;
+
+    p.pause;
+    p.resume;
+})