Convert to TypeScript (#29)

Author: wojtekmaj

.babelrc

@@ -1,20 +1,3 @@
 {
-  "presets": ["@babel/env"],
-  "env": {
-    "production-esm": {
-      "presets": [["@babel/env", { "modules": false }]]
-    },
-    "test": {
-      "presets": [
-        [
-          "@babel/env",
-          {
-            "targets": {
-              "node": "current"
-            }
-          }
-        ]
-      ]
-    }
-  }
+  "presets": ["@babel/typescript", "@babel/env"]
 }

.eslintrc.json

@@ -1,3 +1,9 @@
 {
-  "extends": "wojtekmaj"
+  "extends": [
+    "wojtekmaj",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"]
 }

package.json

@@ -4,19 +4,21 @@
   "description": "A collection of array-related async utilities.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
-  "source": "src/index.js",
+  "source": "src/index.ts",
+  "types": "src/index.ts",
   "sideEffects": false,
   "scripts": {
     "build": "yarn build-esm && yarn build-cjs",
-    "build-esm": "BABEL_ENV=production-esm babel src -d dist/esm --ignore \"**/*.spec.js\"",
-    "build-cjs": "BABEL_ENV=production-cjs babel src -d dist/cjs --ignore \"**/*.spec.js\"",
+    "build-esm": "tsc --project tsconfig.build.json --outDir dist/esm --module esnext",
+    "build-cjs": "tsc --project tsconfig.build.json --outDir dist/cjs --module commonjs",
     "clean": "rimraf dist",
     "jest": "jest",
     "lint": "eslint src",
     "postinstall": "husky install",
     "prepack": "yarn clean && yarn build",
     "prettier": "prettier --check . --cache",
-    "test": "yarn lint && yarn prettier && yarn jest"
+    "test": "yarn lint && yarn tsc && yarn prettier && yarn jest",
+    "tsc": "tsc --noEmit"
   },
   "keywords": [
     "array",
@@ -30,16 +32,20 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@babel/cli": "^7.15.0",
     "@babel/core": "^7.15.0",
     "@babel/preset-env": "^7.15.0",
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/jest": "^29.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.44.0",
     "eslint": "^8.26.0",
     "eslint-config-wojtekmaj": "^0.7.1",
     "husky": "^8.0.0",
     "jest": "^29.0.0",
     "prettier": "^2.7.0",
     "pretty-quick": "^3.1.0",
-    "rimraf": "^3.0.0"
+    "rimraf": "^3.0.0",
+    "typescript": "^4.9.4"
   },
   "resolutions": {
     "semver@7.0.0": "^7.0.0"

src/every.spec.js renamed to src/every.spec.ts

@@ -9,12 +9,12 @@ import {
   throws,
 } from '../test-utils';
 
-function largerOrEqualThanZero(x) {
+function largerOrEqualThanZero(x: number) {
   return x >= 0;
 }
 
-function largerOrEqualThanZeroInRandomTime(x) {
-  return new Promise((resolve) =>
+function largerOrEqualThanZeroInRandomTime(x: number) {
+  return new Promise<boolean>((resolve) =>
     setTimeout(() => {
       resolve(x >= 0);
     }, Math.random() * 100),
@@ -115,4 +115,41 @@ describe('asyncEvery()', () => {
 
     await expect(() => asyncEvery(inputArr, mapper)).rejects.toThrow('Some error');
   });
+
+  it('returns type boolean given function that returns type Promise<boolean>', async () => {
+    // @ts-expect-no-error
+    const result: boolean = await asyncEvery(inputArr, largerOrEqualThanZeroInRandomTime);
+
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('returns type true given function that returns type Promise<true>', async () => {
+    async function trueInRandomTime() {
+      return new Promise<true>((resolve) =>
+        setTimeout(() => {
+          resolve(true);
+        }, Math.random() * 100),
+      );
+    }
+
+    // @ts-expect-no-error
+    const result: true = await asyncEvery(inputArr, trueInRandomTime);
+
+    expect(result).toBe(true);
+  });
+
+  it('returns type false given function that returns type Promise<false>', async () => {
+    async function falseInRandomTime() {
+      return new Promise<false>((resolve) =>
+        setTimeout(() => {
+          resolve(false);
+        }, Math.random() * 100),
+      );
+    }
+
+    // @ts-expect-no-error
+    const result: false = await asyncEvery(inputArr, falseInRandomTime);
+
+    expect(result).toBe(false);
+  });
 });

src/every.js renamed to src/every.ts

@@ -1,12 +1,27 @@
 import asyncForEach from './forEach';
 
-export default function asyncEvery(arr, fn) {
-  let resolved;
+function asyncEvery<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<true>,
+): Promise<true>;
+function asyncEvery<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<false>,
+): Promise<false>;
+function asyncEvery<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<boolean>,
+): Promise<boolean>;
+function asyncEvery<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<boolean>,
+): Promise<boolean> {
+  let resolved: boolean;
   return new Promise((resolve, reject) => {
     asyncForEach(
       arr,
       (cur, idx, arr2) =>
-        new Promise((resolve2, reject2) => {
+        new Promise<void>((resolve2, reject2) => {
           if (resolved) {
             return;
           }
@@ -31,3 +46,5 @@ export default function asyncEvery(arr, fn) {
       });
   });
 }
+
+export default asyncEvery;

src/every_strict.js

@@ -12,12 +12,12 @@ import {
   throws,
 } from '../test-utils';
 
-function largerOrEqualThanZero(x) {
+function largerOrEqualThanZero(x: number) {
   return x >= 0;
 }
 
-function largerOrEqualThanZeroInRandomTime(x) {
-  return new Promise((resolve) =>
+function largerOrEqualThanZeroInRandomTime(x: number) {
+  return new Promise<boolean>((resolve) =>
     setTimeout(() => {
       resolve(x >= 0);
     }, Math.random() * 100),
@@ -26,7 +26,7 @@ function largerOrEqualThanZeroInRandomTime(x) {
 
 describe('asyncEveryStrict()', () => {
   it('example from README works as described', async () => {
-    const indexes = [];
+    const indexes: number[] = [];
 
     const largerThanZero = await asyncEveryStrict([1, 2, 3], async (el, index) => {
       indexes.push(index);
@@ -150,4 +150,41 @@ describe('asyncEveryStrict()', () => {
 
     await expect(() => asyncEveryStrict(inputArr, mapper)).rejects.toThrow('Some error');
   });
+
+  it('returns type boolean given function that returns type Promise<boolean>', async () => {
+    // @ts-expect-no-error
+    const result: boolean = await asyncEveryStrict(inputArr, largerOrEqualThanZeroInRandomTime);
+
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('returns type true given function that returns type Promise<true>', async () => {
+    async function trueInRandomTime() {
+      return new Promise<true>((resolve) =>
+        setTimeout(() => {
+          resolve(true);
+        }, Math.random() * 100),
+      );
+    }
+
+    // @ts-expect-no-error
+    const result: true = await asyncEveryStrict(inputArr, trueInRandomTime);
+
+    expect(result).toBe(true);
+  });
+
+  it('returns type false given function that returns type Promise<false>', async () => {
+    async function falseInRandomTime() {
+      return new Promise<false>((resolve) =>
+        setTimeout(() => {
+          resolve(false);
+        }, Math.random() * 100),
+      );
+    }
+
+    // @ts-expect-no-error
+    const result: false = await asyncEveryStrict(inputArr, falseInRandomTime);
+
+    expect(result).toBe(false);
+  });
 });

src/every_strict.spec.js renamed to src/every_strict.spec.ts

@@ -0,0 +1,50 @@
+import asyncForEachStrict from './forEach_strict';
+
+function asyncEveryStrict<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<true>,
+): Promise<true>;
+function asyncEveryStrict<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<false>,
+): Promise<false>;
+function asyncEveryStrict<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<boolean>,
+): Promise<boolean>;
+function asyncEveryStrict<T>(
+  arr: T[],
+  fn: (cur: T, idx: number, arr: T[]) => Promise<boolean>,
+): Promise<boolean> {
+  let resolved: boolean;
+  return new Promise<boolean>((resolve, reject) => {
+    asyncForEachStrict(
+      arr,
+      (cur, idx, arr2) =>
+        new Promise<void>((resolve2, reject2) => {
+          if (resolved) {
+            return;
+          }
+          fn(cur, idx, arr2)
+            .then((result) => {
+              if (!result) {
+                resolve(false);
+                resolved = true;
+              }
+              resolve2();
+            })
+            .catch(reject2);
+        }),
+    )
+      .then(() => {
+        resolve(true);
+        resolved = true;
+      })
+      .catch((error) => {
+        reject(error);
+        resolved = true;
+      });
+  });
+}
+
+export default asyncEveryStrict;

src/every_strict.ts

@@ -87,4 +87,22 @@ describe('asyncFilter()', () => {
 
     await expect(() => asyncFilter(inputArr, mapper)).rejects.toThrow('Some error');
   });
+
+  it('returns type T[] given function that returns type Promise<boolean>', async () => {
+    // @ts-expect-no-error
+    const result: number[] = await asyncFilter(inputArr, largerThanTwoInRandomTime);
+  });
+
+  it('returns type never[] given function that returns type Promise<false>', async () => {
+    async function falseInRandomTime() {
+      return new Promise<false>((resolve) =>
+        setTimeout(() => {
+          resolve(false);
+        }, Math.random() * 100),
+      );
+    }
+
+    // @ts-expect-no-error
+    const result: never[] = await asyncFilter(inputArr, falseInRandomTime);
+  });
 });