Typescript test

.gitignore

@@ -1,5 +1,7 @@
 .DS_Store
+.nyc_output
 /coverage
 /dist
 /node_modules
+/typings
 npm-debug.log

.travis.yml

@@ -10,7 +10,7 @@ script:
   - npm run lint
   - npm test
 after_success:
-  - npm run coverage
+  - npm run cover
   - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
 cache:
   directories:

package.json

@@ -5,11 +5,12 @@
   "main": "index.js",
   "scripts": {
     "build": "tsc --declaration && cp LICENSE README.md package.json dist/",
-    "clean": "rm -fr coverage dist",
-    "coverage": "remap-istanbul -i coverage/coverage.json -t lcovonly -o coverage/lcov.info",
-    "coverage-html": "remap-istanbul -i coverage/coverage.json -t html -o coverage",
-    "lint": "tslint src/**/*.ts",
-    "test": "babel-node ./node_modules/.bin/istanbul cover --include-all-sources _mocha --report none -- --compilers js:babel-core/register --recursive",
+    "cover": "nyc npm test",
+    "lint": "tslint src/**/*.ts test/**/*.ts",
+    "postinstall": "typings install",
+    "prebuild": "rm -fr dist",
+    "precover": "rm -fr .nyc_output coverage",
+    "test": "mocha --recursive --compilers ts:ts-node/register",
     "watch": "tsc --watch"
   },
   "author": "Shota Nozaki",
@@ -20,19 +21,34 @@
   },
   "homepage": "https://github.com/emonkak/js-enumerable",
   "devDependencies": {
-    "babel-cli": "^6.16.0",
-    "babel-core": "^6.17.0",
-    "babel-plugin-transform-runtime": "^6.15.0",
-    "babel-preset-es2015": "^6.16.0",
-    "babel-preset-stage-0": "^6.16.0",
     "cash-cp": "^0.2.0",
     "cash-rm": "^0.2.0",
     "coveralls": "^2.11.14",
-    "istanbul": "^0.4.5",
     "mocha": "^3.1.0",
-    "remap-istanbul": "^0.6.4",
+    "nyc": "^8.3.0",
     "sinon": "^1.17.6",
+    "ts-node": "^1.3.0",
     "tslint": "^3.15.1",
-    "typescript": "^2.0.3"
+    "typescript": "^2.0.3",
+    "typings": "^1.4.0"
+  },
+  "nyc": {
+    "extension": [
+      ".ts"
+    ],
+    "exclude": [
+      "dist",
+      "node_modules",
+      "typings"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "lcov",
+      "html",
+      "text"
+    ],
+    "all": true
   }
 }

src/Enumerable.ts

@@ -1,12 +1,3 @@
-export class Enumerable<TSource> implements Iterable<TSource> {
-    constructor(private _source: Iterable<TSource>) {
-    }
+import { Enumerable } from './internal/Enumerable';
 
-    [Symbol.iterator](): Iterator<TSource> {
-        return this._source[Symbol.iterator]();
-    }
-
-    lift<TResult>(source: Iterable<TResult>): Enumerable<TResult> {
-        return new Enumerable(source);
-    }
-}
+export default Enumerable;

src/extensions/aggregate.ts

@@ -1,10 +1,10 @@
 import aggregate from '../aggregate';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.aggregate = aggregate;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        aggregate: typeof aggregate;
+        aggregate<TAccumulate>(seed: TAccumulate, func: (result: TAccumulate, element: TSource) => TAccumulate): TAccumulate;
     }
 }

src/extensions/all.ts

@@ -1,10 +1,10 @@
 import all from '../all';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.all = all;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        all: typeof all;
+        all(predicate?: (element: TSource) => boolean): boolean;
     }
 }

src/extensions/any.ts

@@ -1,10 +1,10 @@
 import any from '../any';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.any = any;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        any: typeof any;
+        any(predicate?: (element: TSource) => boolean): boolean;
     }
 }

src/extensions/average.ts

@@ -1,10 +1,10 @@
 import average from '../average';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.average = average;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        average: typeof average;
+        average(selector?: (element: TSource) => number): number;
     }
 }

src/extensions/buffer.ts

@@ -1,10 +1,14 @@
-import buffer from '../lifted/buffer';
-import { Enumerable } from '../Enumerable';
+import bufferFn from '../buffer';
+import { Enumerable } from '../internal/Enumerable';
+
+function buffer<TSource>(this: Enumerable<TSource>, count: number, skip?: number): Enumerable<TSource[]> {
+    return this.lift<TSource[]>(bufferFn.call(this, count, skip));
+}
 
 Enumerable.prototype.buffer = buffer;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        buffer: typeof buffer;
+        buffer(count: number, skip?: number): Enumerable<TSource[]>;
     }
 }

src/extensions/catch.ts

@@ -1,10 +1,14 @@
-import _catch from '../lifted/catch';
-import { Enumerable } from '../Enumerable';
+import catchFn from '../catch';
+import { Enumerable } from '../internal/Enumerable';
+
+function _catch<TSource, TException>(this: Enumerable<TSource>, handler: (exception: TException) => Iterable<TSource>): Enumerable<TSource> {
+    return this.lift<TSource>(catchFn.call(this, handler));
+}
 
 Enumerable.prototype.catch = _catch;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        catch: typeof _catch;
+        catch<TException>(handler: (exception: TException) => Iterable<TSource>): Enumerable<TSource>;
     }
 }

src/extensions/concat.ts

@@ -1,10 +1,14 @@
-import concat from '../lifted/concat';
-import { Enumerable } from '../Enumerable';
+import concatFn from '../concat';
+import { Enumerable } from '../internal/Enumerable';
+
+function concat<TSource>(this: Enumerable<TSource>, ...sources: Iterable<TSource>[]): Enumerable<TSource> {
+    return this.lift<TSource>(concatFn.apply(this, sources));
+}
 
 Enumerable.prototype.concat = concat;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        concat: typeof concat;
+        concat(...sources: Iterable<TSource>[]): Enumerable<TSource>;
     }
 }

src/extensions/count.ts

@@ -1,10 +1,10 @@
 import count from '../count';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.count = count;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        count: typeof count;
+        count(predicate?: (item: TSource) => boolean): number;
     }
 }

src/extensions/defaultIfEmpty.ts

@@ -1,10 +1,14 @@
-import defaultIfEmpty from '../lifted/defaultIfEmpty';
-import { Enumerable } from '../Enumerable';
+import defaultIfEmptyFn from '../defaultIfEmpty';
+import { Enumerable } from '../internal/Enumerable';
+
+function defaultIfEmpty<TSource>(this: Enumerable<TSource>, defaultValue: TSource): Enumerable<TSource> {
+    return this.lift<TSource>(defaultIfEmptyFn.call(this, defaultValue));
+}
 
 Enumerable.prototype.defaultIfEmpty = defaultIfEmpty;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        defaultIfEmpty: typeof defaultIfEmpty;
+        defaultIfEmpty(defaultValue: TSource): Enumerable<TSource>;
     }
 }

src/extensions/distinct.ts

@@ -1,10 +1,16 @@
-import distinct from '../lifted/distinct';
-import { Enumerable } from '../Enumerable';
+import distinctFn from '../distinct';
+import { Enumerable } from '../internal/Enumerable';
+
+function distinct<TSource>(this: Enumerable<TSource>): Enumerable<TSource>;
+function distinct<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (element: TSource) => TKey): Enumerable<TSource> {
+    return this.lift<TSource>(distinctFn.call(this, keySelector));
+}
 
 Enumerable.prototype.distinct = distinct;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        distinct: typeof distinct;
+        distinct(): Enumerable<TSource>;
+        distinct<TKey>(keySelector?: (element: TSource) => TKey): Enumerable<TSource>;
     }
 }

src/extensions/distinctUntilChanged.ts

@@ -1,10 +1,16 @@
-import distinctUntilChanged from '../lifted/distinctUntilChanged';
-import { Enumerable } from '../Enumerable';
+import distinctUntilChangedFn from '../distinctUntilChanged';
+import { Enumerable } from '../internal/Enumerable';
+
+function distinctUntilChanged<TSource>(this: Enumerable<TSource>): Enumerable<TSource>;
+function distinctUntilChanged<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (element: TSource) => TKey): Enumerable<TSource> {
+    return this.lift<TSource>(distinctUntilChangedFn.call(this, keySelector));
+}
 
 Enumerable.prototype.distinctUntilChanged = distinctUntilChanged;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        distinctUntilChanged: typeof distinctUntilChanged;
+        distinctUntilChanged(): Enumerable<TSource>;
+        distinctUntilChanged<TKey>(keySelector?: (element: TSource) => TKey): Enumerable<TSource>;
     }
 }

src/extensions/do.ts

@@ -1,10 +1,14 @@
-import _do from '../lifted/do';
-import { Enumerable } from '../Enumerable';
+import doFn from '../do';
+import { Enumerable } from '../internal/Enumerable';
+
+function _do<TSource>(this: Enumerable<TSource>, action: (element: TSource) => void): Enumerable<TSource> {
+    return this.lift<TSource>(doFn.call(this, action));
+}
 
 Enumerable.prototype.do = _do;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        do: typeof _do;
+        do(action: (element: TSource) => void): Enumerable<TSource>;
     }
 }

src/extensions/doWhile.ts

@@ -1,10 +1,14 @@
-import doWhile from '../lifted/doWhile';
-import { Enumerable } from '../Enumerable';
+import doWhileFn from '../doWhile';
+import { Enumerable } from '../internal/Enumerable';
+
+function doWhile<TSource>(this: Enumerable<TSource>, condition: () => boolean): Enumerable<TSource> {
+    return this.lift<TSource>(doWhileFn.call(this, condition));
+}
 
 Enumerable.prototype.doWhile = doWhile;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        doWhile: typeof doWhile;
+        doWhile(condition: () => boolean): Enumerable<TSource>;
     }
 }

src/extensions/elementAt.ts

@@ -1,10 +1,10 @@
 import elementAt from '../elementAt';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.elementAt = elementAt;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        elementAt: typeof elementAt;
+        elementAt(index: number): TSource;
     }
 }

src/extensions/elementAtOrDefault.ts

@@ -1,10 +1,10 @@
 import elementAtOrDefault from '../elementAtOrDefault';
-import { Enumerable } from '../Enumerable';
+import { Enumerable } from '../internal/Enumerable';
 
 Enumerable.prototype.elementAtOrDefault = elementAtOrDefault;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        elementAtOrDefault: typeof elementAtOrDefault;
+        elementAtOrDefault(index: number, defaultValue?: TSource): TSource;
     }
 }

src/extensions/except.ts

@@ -1,10 +1,14 @@
-import except from '../except';
-import { Enumerable } from '../Enumerable';
+import exceptFn from '../except';
+import { Enumerable } from '../internal/Enumerable';
+
+function except<TSource>(this: Enumerable<TSource>, second: Iterable<TSource>): Enumerable<TSource> {
+    return this.lift<TSource>(exceptFn.call(this, second));
+}
 
 Enumerable.prototype.except = except;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        except: typeof except;
+        except(second: Iterable<TSource>): Enumerable<TSource>;
     }
 }

src/extensions/finally.ts

@@ -1,10 +1,14 @@
-import _finally from '../finally';
-import { Enumerable } from '../Enumerable';
+import finallyFn from '../finally';
+import { Enumerable } from '../internal/Enumerable';
+
+function _finally<TSource>(this: Enumerable<TSource>, finallyAction: () => void): Enumerable<TSource> {
+    return this.lift<TSource>(finallyFn.call(this, finallyAction));
+}
 
 Enumerable.prototype.finally = _finally;
 
-declare module '../Enumerable' {
+declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
-        finally: typeof _finally;
+        finally(finallyAction: () => void): Enumerable<TSource>;
     }
 }