immutable-js · jdeniau · Jun 9, 2025 · Feb 22, 2025 · Feb 25, 2025 · Jun 9, 2025
diff --git a/__tests__/ArraySeq.ts b/__tests__/ArraySeq.ts
@@ -30,7 +30,7 @@ describe('ArraySequence', () => {
 
   it('efficiently chains iteration methods', () => {
     const i = Seq('abcdefghijklmnopqrstuvwxyz'.split(''));
-    function studly(letter, index) {
+    function studly(letter: string, index: number): string {
       return index % 2 === 0 ? letter : letter.toUpperCase();
     }
     const result = i

diff --git a/__tests__/Conversion.ts b/__tests__/Conversion.ts
@@ -1,5 +1,13 @@
 import { describe, expect, it } from '@jest/globals';
-import { fromJS, is, List, Map, OrderedMap, Record } from 'immutable';
+import {
+  type Collection,
+  fromJS,
+  is,
+  List,
+  Map,
+  OrderedMap,
+  Record,
+} from 'immutable';
 import fc, { type JsonValue } from 'fast-check';
 
 describe('Conversion', () => {
@@ -113,29 +121,46 @@ describe('Conversion', () => {
   });
 
   it('Converts deep JSON with custom conversion', () => {
-    const seq = fromJS(js, function (key, sequence) {
-      if (key === 'point') {
-        // @ts-expect-error -- to convert to real typing
-        return new Point(sequence);
+    const seq = fromJS(
+      js,
+      function (
+        this: typeof js,
+        key: PropertyKey,
+        sequence:
+          | Collection.Keyed<string, unknown>
+          | Collection.Indexed<unknown>
+      ) {
+        if (key === 'point') {
+          // @ts-expect-error -- to convert to real typing
+          return new Point(sequence);
+        }
+
+        // @ts-expect-error -- any type for too complex object
+        return Array.isArray(this[key])
+          ? sequence.toList()
+          : sequence.toOrderedMap();
       }
-      return Array.isArray(this[key])
-        ? sequence.toList()
-        : sequence.toOrderedMap();
-    });
+    );
     expect(seq).toEqual(immutableOrderedData);
     expect(seq.toString()).toEqual(immutableOrderedDataString);
   });
 
   it('Converts deep JSON with custom conversion including keypath if requested', () => {
     const paths: Array<Array<string | number> | undefined> = [];
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const seq1 = fromJS(js, function (key, sequence, keypath) {
-      expect(arguments.length).toBe(3);
-      paths.push(keypath);
-      return Array.isArray(this[key])
-        ? sequence.toList()
-        : sequence.toOrderedMap();
-    });
+    const seq1 = fromJS(
+      js,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function (this: typeof js, key: any, sequence, ke
8000
ypath) {
+        expect(arguments.length).toBe(3);
+        paths.push(keypath);
+
+        // @ts-expect-error -- any type for too complex object
+        return Array.isArray(this[key])
+          ? sequence.toList()
+          : sequence.toOrderedMap();
+      }
+    );
     expect(paths).toEqual([
       [],
       ['deepList'],

diff --git a/__tests__/Equality.ts b/__tests__/Equality.ts
@@ -3,14 +3,14 @@ import { is, List, Map, Seq, Set } from 'immutable';
 import fc from 'fast-check';
 
 describe('Equality', () => {
-  function expectIs(left, right) {
+  function expectIs(left: unknown, right: unknown): void {
     const comparison = is(left, right);
     expect(comparison).toBe(true);
     const commutative = is(right, left);
     expect(commutative).toBe(true);
   }
 
-  function expectIsNot(left, right) {
+  function expectIsNot(left: unknown, right: unknown): void {
     const comparison = is(left, right);
     expect(comparison).toBe(false);
     const commutative = is(right, left);

diff --git a/__tests__/KeyedSeq.ts b/__tests__/KeyedSeq.ts
@@ -1,11 +1,12 @@
 import { describe, expect, it } from '@jest/globals';
 import { Range, Seq } from 'immutable';
 import fc from 'fast-check';
+import invariant from '../src/utils/invariant';
 
 describe('KeyedSeq', () => {
   it('iterates equivalently', () => {
     fc.assert(
-      fc.property(fc.array(fc.integer()), (ints) => {
+      fc.property(fc.array(fc.integer()), (ints: Array<number>) => {
         const seq = Seq(ints);
         const keyed = seq.toKeyedSeq();
 
@@ -24,7 +25,7 @@ describe('KeyedSeq', () => {
   });
 
   it('maintains keys', () => {
-    const isEven = (x) => x % 2 === 0;
+    const isEven = (x: number): boolean => x % 2 === 0;
     const seq = Range(0, 100);
 
     // This is what we expect for IndexedSequences
@@ -39,6 +40,10 @@ describe('KeyedSeq', () => {
     const [indexed0, indexed1] = seq
       .partition(isEven)
       .map((part) => part.skip(10).take(5));
+
+    invariant(indexed0, 'indexed0 is not undefined');
+    invariant(indexed1, 'indexed0 is not undefined');
+
     expect(indexed0.entrySeq().toArray()).toEqual([
       [0, 21],
       [1, 23],
@@ -67,6 +72,10 @@ describe('KeyedSeq', () => {
     const [keyed0, keyed1] = keyed
       .partition(isEven)
       .map((part) => part.skip(10).take(5));
+
+    invariant(keyed0, 'keyed0 is not undefined');
+    invariant(keyed1, 'keyed1 is not undefined');
+
     expect(keyed0.entrySeq().toArray()).toEqual([
       [21, 21],
       [23, 23],

diff --git a/__tests__/List.ts b/__tests__/List.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from '@jest/globals';
 import { fromJS, List, Map, Range, Seq, Set } from 'immutable';
 import fc from 'fast-check';
 import { create as createSeed } from 'random-seed';
+import invariant from '../src/utils/invariant';
 
 function arrayOfSize(s: number) {
   const a = new Array(s);
@@ -480,6 +481,8 @@ describe('List', () => {
   });
 
   it.each(['remove', 'delete'])('remove removes any index', (fn) => {
+    invariant(fn === 'remove' || fn === 'delete', 'Invalid function name');
+
     let v = List.of('a', 'b', 'c')[fn](2)[fn](0);
     expect(v.size).toBe(1);
     expect(v.get(0)).toBe('b');
@@ -732,7 +735,7 @@ describe('List', () => {
     expect(v5.toJS().filter((item) => item === 0)).toHaveLength(0);
 
     // execute the same test as `v` but for the 2000 first integers
-    const isOkV1 = (v) =>
+    const isOkV1 = (v: number): boolean =>
       List.of()
         .set(v, v)
         .push('pushed-value')
@@ -763,7 +766,7 @@ describe('List', () => {
 
   it('forEach iteration terminates when callback returns false', () => {
     const a: Array<number> = [];
-    function count(x) {
+    function count(x: number): void | false {
       if (x > 2) {
         return false;
       }
@@ -984,7 +987,7 @@ describe('List', () => {
 
   // Note: NaN is the only value not equal to itself. The isNaN() built-in
   // function returns true for any non-numeric value, not just the NaN value.
-  function isNaNValue(value) {
+  function isNaNValue(value: unknown): boolean {
     return value !== value;
   }
 

diff --git a/__tests__/Map.ts b/__tests__/Map.ts
@@ -471,7 +471,7 @@ describe('Map', () => {
 
   it('uses toString on keys and values', () => {
     class A extends Record({ x: null as number | null }) {
-      toString() {
+      override toString() {
         return this.x;
       }
     }

diff --git a/__tests__/OrderedSet.ts b/__tests__/OrderedSet.ts
@@ -63,7 +63,7 @@ describe('OrderedSet', () => {
    * @see https://github.com/immutable-js/immutable-js/issues/1716
    */
   it('handles `subtract` when Set contains >=32 elements', () => {
-    const fillArray = (nb) =>
+    const fillArray = (nb: number) =>
       Array(nb)
         .fill(1)
         .map((el, i) => i + 1);

diff --git a/__tests__/Predicates.ts b/__tests__/Predicates.ts
@@ -43,7 +43,7 @@ describe('isValueObject', () => {
         this.v = val;
       }
 
-      equals(other) {
+      equals(other: MyValueType) {
         return Boolean(other && this.v === other.v);
       }
 

diff --git a/__tests__/Seq.ts b/__tests__/Seq.ts
@@ -31,18 +31,19 @@ describe('Seq', () => {
   });
 
   it('accepts an object with a next property', () => {
-    expect(Seq({ a: 1, b: 2, next: (_) => _ }).size).toBe(3);
+    expect(Seq({ a: 1, b: 2, next: (_: unknown) => _ }).size).toBe(3);
   });
 
   it('accepts a collection string', () => {
     expect(Seq('foo').size).toBe(3);
   });
 
   it('accepts arbitrary objects', () => {
-    function Foo() {
+    function Foo(this: { bar: string; baz: string }) {
       this.bar = 'bar';
       this.baz = 'baz';
     }
+    // @ts-expect-error -- any type for too complex object
     expect(Seq(new Foo()).size).toBe(2);
   });
 

diff --git a/__tests__/Set.ts b/__tests__/Set.ts
@@ -305,7 +305,7 @@ describe('Set', () => {
         Symbol('a'),
         Symbol('b'),
         Symbol('c'),
-      ];
+      ] as const;
 
       const symbolSet = Set(manySymbols);
       expect(symbolSet.size).toBe(12);

@@ -2,7 +2,7 @@ import { describe, expect, it } from '@jest/globals';
 import { Seq, Stack } from 'immutable';
 import fc from 'fast-check';
 
-function arrayOfSize(s) {
+function arrayOfSize(s: number): Array<number> {
   const a = new Array(s);
   for (let ii = 0; ii < s; ii++) {
     a[ii] = ii;

diff --git a/__tests__/functional/get.ts b/__tests__/functional/get.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from '@jest/globals';
 import { get, Map, List, Range } from 'immutable';
+import invariant from '../../src/utils/invariant';
 
 describe('get', () => {
   it('for immutable structure', () => {
@@ -26,8 +27,10 @@ describe('get', () => {
         {
           x: 'xx',
           y: 'yy',
-          get: function (key: string) {
-            return `${this[key].toUpperCase()}`;
+          get: function (this, key: string) {
+            invariant(typeof this[key] === 'string', 'this[key] is a string');
+
+            return this[key].toUpperCase();
           },
         },
         'x'

diff --git a/__tests__/groupBy.ts b/__tests__/groupBy.ts
@@ -32,7 +32,7 @@ describe('groupBy', () => {
         isObject ? objectConstructor : iterableConstructor
       );
 
-      const grouped = col.groupBy((v) => v);
+      const grouped = col.groupBy((v: unknown) => v);
 
       // all groupBy should be instance of Map
       expect(grouped).toBeInstanceOf(Map);

diff --git a/__tests__/issues.ts b/__tests__/issues.ts
@@ -42,6 +42,7 @@ describe('Issue #1220 : Seq.rest() throws an exception when invoked on a single
       (typeof Symbol === 'function' && Symbol.iterator) || '@@iterator';
 
     const r = Seq([1]).rest();
+    // @ts-expect-error -- any type for too complex object
     const i = r[ITERATOR_SYMBOL]();
     expect(i.next()).toEqual({ value: undefined, done: true });
   });

diff --git a/__tests__/merge.ts b/__tests__/merge.ts
@@ -242,15 +242,18 @@ describe('merge', () => {
     ).toBe(true);
   });
 
-  const map = { type: 'Map', value: Map({ b: 5, c: 9 }) };
-  const object = { type: 'object', value: { b: 7, d: 12 } };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  type TypeValue = { type: any; value: any };
+
+  const map: TypeValue = { type: 'Map', value: Map({ b: 5, c: 9 }) };
+  const object: TypeValue = { type: 'object', value: { b: 7, d: 12 } };
   const RecordFactory = Record({ a: 1, b: 2 });
-  const record = { type: 'Record', value: RecordFactory({ b: 3 }) };
-  const list = { type: 'List', value: List(['5']) };
-  const array = { type: 'array', value: ['9'] };
-  const set = { type: 'Set', value: Set('3') };
+  const record: TypeValue = { type: 'Record', value: RecordFactory({ b: 3 }) };
+  const list: TypeValue = { type: 'List', value: List(['5']) };
+  const array: TypeValue = { type: 'array', value: ['9'] };
+  const set: TypeValue = { type: 'Set', value: Set('3') };
 
-  const incompatibleTypes = [
+  const incompatibleTypes: Array<[TypeValue, TypeValue]> = [
     [map, list],
     [map, array],
     [map, set],

diff --git a/__tests__/slice.ts b/__tests__/slice.ts
@@ -234,8 +234,9 @@ describe('slice', () => {
         (valuesLen, args) => {
           const a = Range(0, valuesLen).toArray();
           const v = List(a);
-          const slicedV = v.slice.apply(v, args);
-          const slicedA = a.slice.apply(a, args);
+
+          const slicedV = v.slice(...args);
+          const slicedA = a.slice(...args);
           expect(slicedV.toArray()).toEqual(slicedA);
         }
       )
@@ -251,8 +252,8 @@ describe('slice', () => {
           const a: Array<number> = [];
           entries.forEach((entry) => (a[entry[0]] = entry[1]));
           const s = Seq(a);
-          const slicedS = s.slice.apply(s, args);
-          const slicedA = a.slice.apply(a, args);
+          const slicedS = s.slice(...args);
+          const slicedA = a.slice(...args);
           expect(slicedS.toArray()).toEqual(slicedA);
         }
       )

diff --git a/__tests__/splice.ts b/__tests__/splice.ts
@@ -51,12 +51,15 @@ describe('splice', () => {
     fc.assert(
       fc.property(
         fc.array(fc.integer()),
-        fc.array(fc.sparseArray(fc.integer())),
-        (values, args) => {
+        fc.integer(),
+        fc.integer(),
+        fc.array(fc.integer()),
+        (values, index, removeNum, insertValues) => {
           const v = List(values);
           const a = values.slice(); // clone
-          const splicedV = v.splice.apply(v, args); // persistent
-          a.splice.apply(a, args); // mutative
+
+          const splicedV = v.splice(index, removeNum, ...insertValues); // persistent
+          a.splice(index, removeNum, ...insertValues); // mutative
           expect(splicedV.toArray()).toEqual(a);
         }
       )