Fix typescript issues

Author: Sascha Dobschal

Computed.d.ts

@@ -1,8 +1,9 @@
 
 interface ComputedValue<T> {
     value: T;
-    subscribe(callback: (value: any) => void): void;
-    unsubscribe(callback: (value: any) => void): void;
+    subscribe(callback: (value: any) => void | Promise<void>): void;
+    unsubscribe(callback: (value: any) => void | Promise<void>): void;
+    isObservable: boolean;
 }
 
 export default function Computed<T>(fn: () => T, deep?: boolean): ComputedValue<T>;

Computed.test.js

@@ -123,6 +123,43 @@ test("deep computed is affected by changes to the observables properties", () =>
     expect(mockedSubscriber).toHaveBeenCalledTimes(2);
 });
 
+test("A computed function with a loop referencing an Observable should not cause an infinite loop", () => {
+    const config = Observable({
+        showItems: true,
+        bla: 1
+    });
+    const items1 = Observable([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    const items2 = Observable([1, 2, 3, 4]);
+    const computed = Computed(() => {
+        return items1.value.filter(i => {
+            return config.value.showItems && items2.value.includes(i);
+        }).map(i => {
+
+            return i * config.value.bla;
+        });
+    });
+    const computedOfComputed = Computed(() => {
+        return computed.value.map(i => i * 2).filter(v => v > 1 && config.value.showItems);
+    });
+    const mockedSubscriber1 = jest.fn();
+    const mockedSubscriber2 = jest.fn();
+    const mockedSubscriber3 = jest.fn();
+    const mockedSubscriber4 = jest.fn();
+    items1.subscribe(mockedSubscriber1);
+    items2.subscribe(mockedSubscriber2);
+    computed.subscribe(mockedSubscriber3);
+    computedOfComputed.subscribe(mockedSubscriber4);
+    expect(computed.value).toEqual([1, 2, 3, 4]);
+    expect(computedOfComputed.value).toEqual([2, 4, 6, 8]);
+    items2.value.push(5);
+    expect(computed.value).toEqual([1, 2, 3, 4, 5]);
+    expect(computedOfComputed.value).toEqual([2, 4, 6, 8, 10]);
+    expect(mockedSubscriber1).toHaveBeenCalledTimes(1);
+    expect(mockedSubscriber2).toHaveBeenCalledTimes(2);
+    expect(mockedSubscriber3).toHaveBeenCalledTimes(2);
+    expect(mockedSubscriber4).toHaveBeenCalledTimes(2);
+});
+
 test("Have two computed arrays --> subscriber is called only once", () => {
     const entries = Observable([{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}], true);
     const categories = Observable([{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}], true);

Observable.d.ts

@@ -1,9 +1,10 @@
 interface ObservableVariable<T> {
+    isObservable: boolean;
     value: T;
     set(value: T): void;
-    subscribe(callback: (value: T) => void): void;
-    unsubscribe(callback: (value: T) => void): void;
-    map(callback: (value: any) => any): ObservableVariable<any>;
+    subscribe(callback: (value: T) => void | Promise<void>): void;
+    unsubscribe(callback: (value: T) => void | Promise<void>): void;
+    map<U>(callback: (value: T) => U): ObservableVariable<U>;
 }
 
 export default function Observable<T>(initialValue: T, deep?: boolean): ObservableVariable<T>;