Add type tests using Vitest (and fix any issues found along the way) (#32)

* add type test setup

* fix window event map

* add catch type test and fix typing

* add type predicate overload to .find

* tests for catch, constructor, drop, every, finally, foreach, some, take

* tests for filter, find, first, flatMap, forEach, inspect, last, map, switchMap, toArray

* test for reduce, and add overloads

* tests for from, takeUntil

* add type tests to CI

* run type tests before publish

* .catch must return a valid ObservableInput

* add some more tests for ObservableInput accepting methods

* remove unused import

* enforce use of npm

Author: EskiMojo14

.github/workflows/publish.yml

@@ -21,6 +21,7 @@ jobs:
       - run: npm install -g npm@latest
       - run: npm i
       - run: npm test
+      - run: npm run test:types
       - run: npm run minify
       - run: npm version ${TAG_NAME} --git-tag-version=false
         env:

.github/workflows/test.yml

@@ -10,13 +10,16 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js 22.x
-      uses: actions/setup-node@v4
-      with:
-        node-version: 22.x
-    - name: npm install, build, and test
-      run: |
-        npm it
-      env:
-        CI: true
+      - uses: actions/checkout@v4
+      - name: Use Node.js 22.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22.x
+      - name: npm install, build, and test
+        run: |
+          npm it
+        env:
+          CI: true
+
+      - name: test types
+        run: npm run test:types

index.d.ts

@@ -53,10 +53,10 @@ declare global {
   }
 
   interface Window {
-    when<T extends keyof HTMLElementEventMap>(
+    when<T extends keyof WindowEventMap>(
       event: T,
       options?: ObservableEventListenerOptions
-    ): Observable<HTMLElementEventMap[T]>;
+    ): Observable<WindowEventMap[T]>;
     when(
       type: string,
       options?: ObservableEventListenerOptions

observable.d.ts

@@ -49,7 +49,7 @@ export type Reducer<T = any, R = any> = (
 ) => R;
 export type Mapper<T = any, R = any> = (value: T, index: number) => R;
 export type Visitor<T = any> = (value: T, index: number) => void;
-export type CatchCallback<R = any> = (value: any) => Observable<R> | R;
+export type CatchCallback<R = any> = (value: any) => ObservableInput<R>;
 
 export type ObservableInput<T> =
   | Observable<T>
@@ -70,21 +70,35 @@ export class Observable<T = any> {
   flatMap<R>(mapper: Mapper<T, ObservableInput<R>>): Observable<R>;
   switchMap<R>(mapper: Mapper<T, ObservableInput<R>>): Observable<R>;
   inspect(inspectorUnion?: ObservableInspectorUnion<T>): Observable<T>;
-  catch(callback: CatchCallback): Observable<T>;
+  catch<R>(callback: CatchCallback<R>): Observable<T | R>;
   finally(callback: () => void): Observable<T>;
   toArray(options?: SubscribeOptions): Promise<T[]>;
   forEach(callback: Visitor<T>, options?: SubscribeOptions): Promise<void>;
   every(predicate: Predicate<T>, options?: SubscribeOptions): Promise<boolean>;
   first(options?: SubscribeOptions): Promise<T>;
   last(options?: SubscribeOptions): Promise<T>;
+  find<U extends T>(
+    predicate: TypePredicate<T, U>,
+    options?: SubscribeOptions
+  ): Promise<U | undefined>;
   find(
     predicate: Predicate<T>,
     options?: SubscribeOptions
   ): Promise<T | undefined>;
   some(predicate: Predicate<T>, options?: SubscribeOptions): Promise<boolean>;
+  reduce(
+    reducer: Reducer<T, T>,
+    initialValue?: undefined,
+    options?: SubscribeOptions
+  ): Promise<T | undefined>;
+  reduce(
+    reducer: Reducer<T, T>,
+    initialValue: T,
+    options?: SubscribeOptions
+  ): Promise<T>;
   reduce<R>(
     reducer: Reducer<T, R>,
-    initialValue?: R,
+    initialValue: R,
     options?: SubscribeOptions
   ): Promise<R>;
 }