From ce9db42180a7cc20f5f8308f1fb89f902e0b4179 Mon Sep 17 00:00:00 2001
From: Matt Pocock <mattpocockvoice@gmail.com>
Date: Wed, 8 Mar 2023 16:22:54 +0000
Subject: [PATCH] Added support for `indexOf` #91

---
 .changeset/angry-hotels-remember.md |   5 ++
 package.json                        |   5 ++
 readme.md                           |   8 ++
 src/entrypoints/array-index-of.d.ts |  23 +++++
 src/entrypoints/recommended.d.ts    |   1 +
 src/tests/array-index-of.ts         | 133 ++++++++++++++++++++++++++++
 6 files changed, 175 insertions(+)
 create mode 100644 .changeset/angry-hotels-remember.md
 create mode 100644 src/entrypoints/array-index-of.d.ts
 create mode 100644 src/tests/array-index-of.ts

diff --git a/.changeset/angry-hotels-remember.md b/.changeset/angry-hotels-remember.md
new file mode 100644
index 0000000..9c2ea51
--- /dev/null
+++ b/.changeset/angry-hotels-remember.md
@@ -0,0 +1,5 @@
+---
+"@total-typescript/ts-reset": minor
+---
+
+Added support for widening in `Array.lastIndexOf`, `Array.indexOf`, `ReadonlyArray.lastIndexOf` and `ReadonlyArray.indexOf`.
diff --git a/package.json b/package.json
index 852d943..fd72347 100644
--- a/package.json
+++ b/package.json
@@ -67,6 +67,11 @@
       "types": "./dist/utils.d.ts",
       "import": "./dist/utils.mjs",
       "default": "./dist/utils.js"
+    },
+    "./array-index-of": {
+      "types": "./dist/array-index-of.d.ts",
+      "import": "./dist/array-index-of.mjs",
+      "default": "./dist/array-index-of.js"
     }
   },
   "keywords": [],
diff --git a/readme.md b/readme.md
index a64e6d9..68f6a2b 100644
--- a/readme.md
+++ b/readme.md
@@ -188,6 +188,14 @@ users.includes("bryan");
 
 This means you can test non-members of the array safely.
 
+### Make `.indexOf` on `as const` arrays less strict
+
+```ts
+import "@total-typescript/ts-reset/array-index-of";
+```
+
+Exactly the same behaviour of `.includes` (explained above), but for `.lastIndexOf` and `.indexOf`.
+
 ### Make `Set.has()` less strict
 
 ```ts
diff --git a/src/entrypoints/array-index-of.d.ts b/src/entrypoints/array-index-of.d.ts
new file mode 100644
index 0000000..2e42001
--- /dev/null
+++ b/src/entrypoints/array-index-of.d.ts
@@ -0,0 +1,23 @@
+/// <reference path="utils.d.ts" />
+
+interface ReadonlyArray<T> {
+  lastIndexOf(
+    searchElement: T | (TSReset.WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): number;
+  indexOf(
+    searchElement: T | (TSReset.WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): number;
+}
+
+interface Array<T> {
+  lastIndexOf(
+    searchElement: T | (TSReset.WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): number;
+  indexOf(
+    searchElement: T | (TSReset.WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): number;
+}
diff --git a/src/entrypoints/recommended.d.ts b/src/entrypoints/recommended.d.ts
index c3d9a3e..7e6b2b4 100644
--- a/src/entrypoints/recommended.d.ts
+++ b/src/entrypoints/recommended.d.ts
@@ -5,3 +5,4 @@
 /// <reference path="array-includes.d.ts" />
 /// <reference path="set-has.d.ts" />
 /// <reference path="map-has.d.ts" />
+/// <reference path="array-index-of.d.ts" />
diff --git a/src/tests/array-index-of.ts b/src/tests/array-index-of.ts
new file mode 100644
index 0000000..fd380af
--- /dev/null
+++ b/src/tests/array-index-of.ts
@@ -0,0 +1,133 @@
+import { doNotExecute, Equal, Expect } from "./utils";
+
+doNotExecute(async () => {
+  const arr = ["1", "2", "3"] as const;
+
+  // Look ma, no error!
+  arr.indexOf("4");
+
+  // Look ma, proper errors!
+  arr.indexOf(
+    // @ts-expect-error
+    2,
+  );
+  arr.indexOf(
+    // @ts-expect-error
+    true,
+  );
+});
+
+doNotExecute(async () => {
+  const arr = [1, 2, 3] as const;
+
+  arr.indexOf(4);
+  arr.indexOf(
+    // @ts-expect-error
+    true,
+  );
+  arr.indexOf(
+    // @ts-expect-error
+    "str",
+  );
+});
+
+doNotExecute(async () => {
+  const arr = [
+    { a: 1 },
+    {
+      a: 2,
+    },
+    {
+      a: 3,
+    },
+  ] as const;
+
+  arr.indexOf(
+    // @ts-expect-error
+    4,
+  );
+
+  arr.indexOf({ a: 1 });
+});
+
+doNotExecute(async () => {
+  const arr: Array<"1" | "2" | "3"> = ["1", "2", "3"];
+
+  arr.indexOf("4");
+
+  arr.indexOf(
+    // @ts-expect-error
+    2,
+  );
+  arr.indexOf(
+    // @ts-expect-error
+    true,
+  );
+});
+
+// lastIndexOf
+
+doNotExecute(async () => {
+  const arr = ["1", "2", "3"] as const;
+
+  // Look ma, no error!
+  arr.lastIndexOf("4");
+
+  // Look ma, proper errors!
+  arr.lastIndexOf(
+    // @ts-expect-error
+    2,
+  );
+  arr.lastIndexOf(
+    // @ts-expect-error
+    true,
+  );
+});
+
+doNotExecute(async () => {
+  const arr = [1, 2, 3] as const;
+
+  arr.lastIndexOf(4);
+  arr.lastIndexOf(
+    // @ts-expect-error
+    true,
+  );
+  arr.lastIndexOf(
+    // @ts-expect-error
+    "str",
+  );
+});
+
+doNotExecute(async () => {
+  const arr = [
+    { a: 1 },
+    {
+      a: 2,
+    },
+    {
+      a: 3,
+    },
+  ] as const;
+
+  arr.lastIndexOf(
+    // @ts-expect-error
+    4,
+  );
+
+  arr.lastIndexOf({ a: 1 });
+});
+
+doNotExecute(async () => {
+  const arr: Array<"1" | "2" | "3"> = ["1", "2", "3"];
+
+  arr.lastIndexOf("4");
+
+  arr.lastIndexOf(
+    // @ts-expect-error
+    2,
+  );
+  arr.lastIndexOf(
+    // @ts-expect-error
+    true,
+  );
+});