chore(typings): Adding plumbing to allow the types added to Observable by default, to come from one

Author: david-driscoll

package.json

@@ -13,11 +13,11 @@
   },
   "scripts": {
     "build_all": "npm run build_es6 && npm run build_amd && npm run build_cjs && npm run build_global && npm run generate_packages",
-    "build_amd": "rm -rf dist/amd && tsc typings/es6-shim/es6-shim.d.ts src/Rx.ts -m amd --outDir dist/amd --sourcemap --target ES5 --diagnostics --pretty",
-    "build_cjs": "rm -rf dist/cjs && tsc typings/es6-shim/es6-shim.d.ts src/Rx.ts src/Rx.KitchenSink.ts -m commonjs --outDir dist/cjs --sourcemap --target ES5 -d --diagnostics --pretty",
-    "build_es6": "rm -rf dist/es6 && tsc src/Rx.ts src/Rx.KitchenSink.ts --outDir dist/es6 --sourceMap --target ES6 -d --diagnostics --pretty",
+    "build_amd": "npm run build_operators && rm -rf dist/amd && tsc typings/es6-shim/es6-shim.d.ts src/Rx.ts -m amd --outDir dist/amd --sourcemap --target ES5 --diagnostics --pretty",
+    "build_cjs": "npm run build_operators && rm -rf dist/cjs && tsc typings/es6-shim/es6-shim.d.ts src/Rx.ts src/Rx.KitchenSink.ts -m commonjs --outDir dist/cjs --sourcemap --target ES5 -d --diagnostics --pretty",
+    "build_es6": "npm run build_operators && rm -rf dist/es6 && tsc src/Rx.ts src/Rx.KitchenSink.ts --outDir dist/es6 --sourceMap --target ES6 -d --diagnostics --pretty",
     "build_closure": "java -jar ./node_modules/google-closure-compiler/compiler.jar ./dist/global/Rx.js --language_in ECMASCRIPT5 --create_source_map ./dist/global/Rx.min.js.map --js_output_file ./dist/global/Rx.min.js",
-    "build_global": "rm -rf dist/global && mkdir \"dist/global\" && browserify src/Rx.global.js --outfile dist/global/Rx.js && npm run build_closure",
+    "build_global": "npm run build_operators && rm -rf dist/global && mkdir \"dist/global\" && browserify src/Rx.global.js --outfile dist/global/Rx.js && npm run build_closure",
     "build_perf": "npm run build_cjs && npm run build_global && webdriver-manager update && npm run perf",
     "build_test": "rm -rf dist/ && npm run lint && npm run build_cjs && jasmine",
     "build_cover": "rm -rf dist/ && npm run lint && npm run build_cjs && npm run cover",
@@ -37,7 +37,8 @@
     "generate_packages": "node .make-packages.js",
     "generate_operator_patches": "tsc -outDir dist/ ./tools/generate-operator-patches.ts && node ./dist/generate-operator-patches.js --exec",
     "commit": "git-cz",
-    "check_circular_dependencies": "madge ./dist/cjs --circular"
+    "check_circular_dependencies": "madge ./dist/cjs --circular",
+	"build_operators": "node typingsgen.js"
   },
   "repository": {
     "type": "git",

src/CoreOperators.ts

@@ -4,6 +4,9 @@ import {ConnectableObservable} from './observable/ConnectableObservable';
 import {Subject} from './Subject';
 import {GroupedObservable} from './operator/groupBy-support';
 import {Notification} from './Notification';
+/* tslint:disable */
+import * as operator from './operator-typings';
+/* tslint:enable */
 
 export interface CoreOperators<T> {
   buffer?: (closingNotifier: Observable<any>) => Observable<T[]>;

src/Observable.ts

@@ -12,6 +12,12 @@ import {Subject} from './Subject';
 import {Notification} from './Notification';
 import {rxSubscriber} from'./symbol/rxSubscriber';
 
+<<<<<<< HEAD
+=======
+/* tslint:disable */
+import * as operator from './operator-typings';
+/* tslint:enable */
+>>>>>>> chore(typings): Adding plumbing to allow the types added to Observable by default, to come from one
 import {combineLatest as combineLatestStatic} from './operator/combineLatest-static';
 import {concat as concatStatic} from './operator/concat-static';
 import {merge as mergeStatic} from './operator/merge-static';

src/operator-typings.ts

@@ -0,0 +1,14 @@
+/* tslint:disable:class-name */ /* tslint:disable:no-unused-variable */ /* tslint:disable:max-line-length */
+import {Observable} from './Observable';
+import {ConnectableObservable} from './observable/ConnectableObservable';
+import {Scheduler} from './Scheduler';
+import {Notification} from './Notification';
+import {Subject} from './Subject';
+import {Observer} from './Observer';
+import {GroupedObservable} from './operator/groupBy-support';
+import {GroupByObservable} from './operator/groupBy';
+import {TimeInterval} from './operator/extended/timeInterval';
+import {ObservableOrPromise, ArrayOrIterator, _Selector, _IndexSelector, _SwitchMapResultSelector, _ObservableMergeMapProjector, _IteratorMergeMapProjector, _Predicate, _PredicateObservable, _Comparer, _Accumulator, _MergeAccumulator} from './types';
+
+/* ||| MARKER ||| */
+/* ||| MARKER ||| */

src/types.ts

@@ -0,0 +1,16 @@
+import {Observable} from './Observable';
+export type ObservableOrPromise<T> = Observable<T> | Promise<T>;
+export type ArrayOrIterator<T> = Iterator<T> | ArrayLike<T> | Array<T>;
+
+export type _Selector<T, TResult> = (value: T) => TResult;
+export type _IndexSelector<T, TResult> = (value: T, index: number) => TResult;
+export type _SwitchMapResultSelector<T1, T2, TResult> = (outerValue: T1, innerValue: T2, outerIndex: number, innerIndex: number) => TResult;
+export type _ObservableMergeMapProjector<T, R> = (value: T, index: number) => ObservableOrPromise<R>;
+export type _IteratorMergeMapProjector<T, R> = (value: T, index: number) => ArrayOrIterator<R>;
+
+export type _Predicate<T> = _Selector<T, boolean>;
+export type _PredicateObservable<T> = (value: T, index: number, observable: Observable<T>) => boolean;
+
+export type _Comparer<T, TResult> = (value1: T, value2: T) => TResult;
+export type _Accumulator<T, TAcc> = (acc: TAcc, value: T) => TAcc;
+export type _MergeAccumulator<T, TAcc> = (acc: TAcc, value: T) => Observable<TAcc>;

tsconfig.json

@@ -7,8 +7,22 @@
     "target": "es6",
     "outDir": "dist/es6"
   },
-   "files": [
-     "src/Rx.ts",
-     "src/Rx.KitchenSink.ts"
-   ]
+  "formatCodeOptions": {
+    "indentSize": 2,
+    "tabSize": 2,
+    "convertTabsToSpaces": true,
+    "insertSpaceAfterCommaDelimiter": true,
+    "insertSpaceAfterSemicolonInForStatements": true,
+    "insertSpaceBeforeAndAfterBinaryOperators": true,
+    "insertSpaceAfterKeywordsInControlFlowStatements": true,
+    "insertSpaceAfterFunctionKeywordForAnonymousFunctions": false,
+    "insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis": false,
+    "placeOpenBraceOnNewLineForFunctions": false,
+    "placeOpenBraceOnNewLineForControlBlocks": false
+  },
+  "files": [
+    "typings/es6-build-shim.d.ts",
+    "src/Rx.ts",
+    "src/Rx.KitchenSink.ts"
+  ]
 }

typings/es6-build-shim.d.ts

@@ -0,0 +1 @@
+declare type IterableShim<T> = Iterable<T>;

typingsgen.js

@@ -0,0 +1,66 @@
+var fs = require('fs');
+var regex = /export interface .*?Operators<T> \{([\S|\s]*)\}/;
+
+var core = fs.readFileSync('./src/CoreOperators.ts').toString();
+var kitchenSink = fs.readFileSync('./src/Rx.KitchenSink.ts').toString();
+var combinedMethods = core.match(regex)[1].trim() + '\n' + kitchenSink.match(regex)[1].trim();
+var contents = combinedMethods.split('\n');
+
+var operators = {};
+var fileResult = '';
+
+for (var i = 0; i < contents.length; i++) {
+  var item = contents[i].trim();
+  if (item) {
+    var file = item.match(/(.*?)\: operator.operator_proto_(.*?)<T>;/);
+    if (!file) {
+      continue;
+    }
+
+    var filename = file[2].trim();
+    var fileContent;
+
+    if (fs.existsSync('./src/operator/' + filename + '.ts')) {
+        fileContent = fs.readFileSync('./src/operator/' + filename + '.ts').toString();
+    } else {
+        fileContent = fs.readFileSync('./src/operator/extended/' + filename + '.ts').toString();
+    }
+
+    var methods = [];
+
+    var r = new RegExp('export function [_]?' + filename + '([\\s|\\S]*?[\\;\\{])', 'g');
+
+    do {
+      var result = r.exec(fileContent);
+      if (result) {
+        var method = result[1].trim();
+        if (methods.length > 0 && method.indexOf('{') > -1) {
+          continue;
+        }
+
+        method = method.split(/\n/g)
+          .filter(function (x) { return !!x; })
+          .map(function (x) { return ('' + x).trim(); })
+          .join(' ')
+          .replace(/ = .*?([\,|\)])/g, '$1');
+
+        if (method[method.length - 1] === ';' || method[method.length - 1] === '{') {
+          method = method.substr(0, method.length - 1).trim();
+        }
+
+        method = method.replace(/^<T>/, '').replace(/^<T, /, '<');
+        methods.push(method);
+      }
+    } while(result);
+
+    if (!operators[filename]) {
+      operators[filename] = true;
+      fileResult += 'export interface operator_proto_' + filename + '<T> {\n  ' + methods.join(';\n  ') + ';\n}\n';
+    }
+  }
+}
+
+var typingsContent = fs.readFileSync('./src/operator-typings.ts').toString();
+fileResult = '/* ||| MARKER ||| */\n' + fileResult + '/* ||| MARKER ||| */';
+typingsContent = typingsContent.replace(/(\/\* \|\|\| MARKER \|\|\| \*\/[\s|\S]*?\/\* \|\|\| MARKER \|\|\| \*\/)/, fileResult);
+fs.writeFileSync('./src/operator-typings.ts', typingsContent);