[add] Test Script based on Jest

[add] Building scripts
[fix] Several details

Author: TechQuery

.gitignore

@@ -1,4 +1,5 @@
 node_modules/
 package-lock.json
 dist/
+.rts2_cache_*/
 docs/

ReadMe.md

@@ -2,6 +2,30 @@
 
 [Observable Proposal][1] implement based on [Async Generator (ES 2018)][2] & [TypeScript][3]
 
+## Usage
+
+```javascript
+import { Observable } from 'waterwheel';
+
+var count = 0,
+    list = [];
+
+const observable = new Observable(({ next, complete }: Observer) => {
+    const timer = setInterval(
+        () => (++count < 5 ? next(count) : complete(count)),
+        0
+    );
+
+    return () => clearInterval(timer);
+});
+
+(async () => {
+    for await (const item of observable) list.push(item);
+
+    console.log(list); // [1, 2, 3, 4, 5]
+})();
+```
+
 [1]: https://github.com/tc39/proposal-observable
 [2]: https://tc39.es/ecma262/#sec-asyncgeneratorfunction-objects
 [3]: https://www.typescriptlang.org/

package.json

@@ -1,6 +1,6 @@
 {
-    "name": "WaterWheel",
-    "version": "1.0.0-alpha.0",
+    "name": "waterwheel",
+    "version": "1.0.0-alpha.1",
     "license": "LGPL-3.0",
     "author": "[email protected]",
     "description": "Observable Proposal implement based on Async Generator (ES 2018) & TypeScript",
@@ -21,11 +21,21 @@
     "bugs": {
         "url": "https://github.com/EasyWebApp/WaterWheel/issues"
     },
-    "main": "dist/index.js",
+    "source": "source/index.ts",
+    "types": "dist/index.d.ts",
+    "main": "dist/waterwheel.umd.js",
+    "module": "dist/waterwheel.js",
     "devDependencies": {
+        "@types/jest": "^24.0.23",
         "husky": "^3.0.9",
+        "jest": "^24.9.0",
         "lint-staged": "^9.4.3",
-        "prettier": "^1.19.1"
+        "microbundle": "^0.11.0",
+        "open-cli": "^5.0.0",
+        "prettier": "^1.19.1",
+        "ts-jest": "^24.2.0",
+        "typedoc": "^0.15.2",
+        "typescript": "^3.7.2"
     },
     "prettier": {
         "singleQuote": true,
@@ -37,12 +47,28 @@
             "git add"
         ]
     },
+    "jest": {
+        "preset": "ts-jest",
+        "testEnvironment": "node",
+        "testRegex": "/test/.*\\.(test|spec)?\\.ts$",
+        "moduleFileExtensions": [
+            "js",
+            "ts",
+            "json"
+        ]
+    },
     "scripts": {
-        "test": "lint-staged"
+        "test": "lint-staged && jest",
+        "debug": "node --inspect node_modules/jest/bin/jest --runInBand",
+        "pack-docs": "typedoc --name WaterWheel --out docs/ source/",
+        "build": "microbundle  &&  npm run pack-docs",
+        "help": "npm run pack-docs  &&  open-cli docs/index.html",
+        "prepublishOnly": "npm test  &&  npm run build"
     },
     "husky": {
         "hooks": {
-            "pre-commit": "npm test"
+            "pre-commit": "npm test",
+            "pre-push": "npm run build"
         }
     }
 }

source/Observable.ts

@@ -1,45 +1,44 @@
 import { Defer, makeDefer } from './utility';
 
-export interface Observer {
-    next(value: any): void;
+export interface Observer<T = any> {
+    next(value: T): void;
     error(reason: string | Error): void;
-    complete(value: any): void;
+    complete(value: T): void;
 }
 
-export type SubscriberFunction = (observer: Observer) => () => void;
+export type SubscriberFunction = (observer: Observer) => (() => void) | void;
 
-export default class Observable {
+export class Observable<T = any> {
     private subscriber: SubscriberFunction;
 
     constructor(subscriber: SubscriberFunction) {
         this.subscriber = subscriber;
     }
 
     async *[Symbol.asyncIterator]() {
-        var queue: Defer[] = [makeDefer()],
-            cursor = 0,
-            canceler: () => void,
+        var queue: Defer<T>[] = [makeDefer<T>()],
+            canceler: (() => void) | void,
             done = false;
 
-        const observer: Observer = {
+        const observer: Observer<T> = {
             next(value) {
                 if (done) return;
 
-                queue[cursor++].resolve(value);
+                queue[queue.length - 1].resolve(value);
 
                 queue.push(makeDefer());
             },
             error(reason) {
                 if (done) return;
 
-                queue[cursor].reject(reason), (done = true);
+                queue[queue.length - 1].reject(reason), (done = true);
 
                 if (canceler) canceler();
             },
             complete(value) {
                 if (done) return;
 
-                queue[cursor++].resolve(value), (done = true);
+                queue[queue.length - 1].resolve(value), (done = true);
 
                 if (canceler) canceler();
             }
@@ -48,10 +47,11 @@ export default class Observable {
         canceler = this.subscriber(observer);
 
         while (true) {
-            if (!done) yield queue[0].promise;
-            else return queue[0].promise;
+            yield queue[0].promise;
 
-            queue.shift(), cursor--;
+            queue.shift();
+
+            if (done) break;
         }
     }
 }

source/utility.ts

@@ -1,6 +1,6 @@
 export interface Defer<T = any> {
     promise: Promise<T>;
-    resolve: (data: any) => void;
+    resolve: (data: T) => void;
     reject: (error: Error | string) => void;
 }
 

test/index.html

@@ -0,0 +1,46 @@
+import { Observable, Observer } from '../source';
+
+describe('Observable', () => {
+    var observable: Observable, timer: any;
+
+    const cleaner = jest.fn(() => clearInterval(timer));
+
+    it('should not call Subscriber Function while constructing', () => {
+        var count = 0;
+
+        const subscriber = jest.fn(({ next, complete }: Observer) => {
+            timer = setInterval(
+                () => (++count < 5 ? next(count) : complete(count)),
+                0
+            );
+
+            return cleaner;
+        });
+
+        observable = new Observable<number>(subscriber);
+
+        expect(subscriber).toBeCalledTimes(0);
+    });
+
+    it('should iterate Limited items asynchronously', async () => {
+        const list = [];
+
+        for await (const item of observable) list.push(item);
+
+        expect(list).toEqual(expect.arrayContaining([1, 2, 3, 4, 5]));
+
+        expect(cleaner).toBeCalledTimes(1);
+    });
+
+    it('should throw Error after error() called', () => {
+        const observable = new Observable(({ error }) => {
+            error(new Error('test'));
+        });
+
+        expect(
+            (async () => {
+                for await (const item of observable);
+            })()
+        ).rejects.toStrictEqual(new Error('test'));
+    });
+});

test/index.js

@@ -1,6 +1,6 @@
 {
     "compilerOptions": {
-        "module": "umd",
+        "module": "es6",
         "moduleResolution": "node",
         "esModuleInterop": true,
         "target": "es5",