Added support for indexOf #91

.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`.

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": [],

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

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;
+}

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" />

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,
+  );
+});