[zen-observable.d.ts] Add definitions for zen-observable

types/zen-observable/index.d.ts

@@ -0,0 +1,63 @@
+// Type definitions for zen-observable v0.5.1
+// Project: https://github.com/zenparsing/zen-observable
+// Definitions by: Kombu <https://github.com/aicest>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare global {
+    interface SymbolConstructor {
+        observable: symbol;
+    }
+}
+
+declare global {
+    namespace ZenObservable {
+        interface SubscriptionObserver<T> {
+            closed: boolean;
+            next(value: T): void;
+            error(errorValue: any): void;
+            complete(): void;
+        }
+
+        interface Subscription {
+            closed: boolean;
+            unsubscribe(): void;
+        }
+
+        interface Observer<T> {
+            start?(subscription: Subscription): any;
+            next?(value: T): void;
+            error?(errorValue: any): void;
+            complete?(): void;
+        }
+
+        type Subscriber<T> = (observer: SubscriptionObserver<T>) => void | (() => void) | Subscription;
+
+        interface ObservableLike<T> {
+            subscribe?: Subscriber<T>;
+            [Symbol.observable](): Observable<T> | ObservableLike<T>;
+        }
+    }
+}
+
+declare class Observable<T> {
+    constructor(subscriber: ZenObservable.Subscriber<T>)
+
+    subscribe(observer: ZenObservable.Observer<T>): ZenObservable.Subscription;
+    subscribe(onNext: (value: T) => void, onError?: (error: any) => void, onComplete?: () => void): ZenObservable.Subscription;
+
+    [Symbol.observable](): Observable<T>;
+
+    forEach(callback: (value: T) => void): Promise<void>;
+    map<R>(callback: (value: T) => R): Observable<R>;
+    filter(callback: (value: T) => boolean): Observable<T>;
+    reduce(callback: (previousValue: T, currentValue: T) => T, initialValue?: T): Observable<T>;
+    reduce<R>(callback: (previousValue: R, currentValue: T) => R, initialValue?: R): Observable<R>;
+    flatMap<R>(callback: (value: T) => ZenObservable.ObservableLike<R>): Observable<R>;
+}
+
+declare namespace Observable {
+    function from<T>(observable: Observable<T> | ZenObservable.ObservableLike<T> | ArrayLike<T>): Observable<T>;
+    function of<T>(...items: T[]): Observable<T>;
+}
+
+export = Observable;

types/zen-observable/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": [
+      "es6"
+    ],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "index.d.ts",
+    "zen-observable-tests.ts"
+  ]
+}

types/zen-observable/tslint.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../tslint.json"
+}

types/zen-observable/zen-observable-tests.ts

@@ -0,0 +1,105 @@
+import * as Observable from 'zen-observable';
+
+const assert = (val: boolean) => {
+    if (val !== true) {
+        throw new Error('Assertion Failure');
+    }
+};
+
+/**
+ * Observable
+ */
+
+new Observable<number>(observer => {
+    [1, 2, 3].forEach(one => observer.next(one));
+    observer.complete();
+})
+    .subscribe(val => assert(typeof val === 'number'));
+
+/**
+ * Observable.of
+ */
+
+Observable.of(1, 2, 3)
+    .subscribe(val => assert(typeof val === 'number'));
+
+/**
+ * Observable.from
+ */
+
+Observable.from(Observable.of(1, 2, 3))
+    .subscribe(val => assert(typeof val === 'number'));
+
+Observable.from([1, 2, 3])
+    .subscribe(val => assert(typeof val === 'number'));
+
+Observable.from({
+    subscribe(observer: ZenObservable.SubscriptionObserver<number>) {
+        [1, 2, 3].forEach(one => observer.next(one));
+        observer.complete();
+    },
+    [Symbol.observable](this: ZenObservable.ObservableLike<number>) {
+        return this;
+    }
+})
+    .subscribe(val => assert(typeof val === 'number'));
+
+Observable.from({
+    [Symbol.observable]() {
+        return Observable.of(1, 2, 3);
+    }
+})
+    .subscribe(val => assert(typeof val === 'number'));
+
+/**
+ * observable.forEach
+ */
+
+Observable.of(1, 2, 3)
+    .forEach(val => assert(typeof val === 'number'));
+
+/**
+ * observable.map
+ */
+
+Observable.of(1, 2, 3)
+    .map(val => val.toString())
+    .subscribe(val => assert(typeof val === 'string'));
+
+/**
+ * observable.filter
+ */
+
+Observable.of(1, 2, 3)
+    .filter(val => val !== 2)
+    .subscribe(val => assert(typeof val === 'number' && val !== 2));
+
+/**
+ * observable.reduce
+ */
+
+Observable.of(1, 2, 3)
+    .reduce((acc, val) => acc + val)
+    .subscribe(val => assert(val === 6));
+
+Observable.of(1, 2, 3)
+    .reduce((acc, val) => acc + val, '')
+    .subscribe(val => assert(val === '123'));
+
+/**
+ * observable.flatMap
+ */
+
+Observable.of(1, 2, 3)
+    .flatMap(val => Observable.of(val.toString()))
+    .subscribe(val => assert(typeof val === 'string'));
+
+/**
+ * ZenObservable
+ */
+
+let subscriptionObserver: ZenObservable.SubscriptionObserver<never>;
+let subscription: ZenObservable.Subscription;
+let observer: ZenObservable.Observer<never>;
+let subscriber: ZenObservable.Subscriber<never>;
+let observableLike: ZenObservable.ObservableLike<never>;