immutable-js · jdeniau · Feb 23, 2025 · Feb 22, 2025 · Feb 22, 2025 · Feb 23, 2025
diff --git a/.github/workflows/output_diff.yml b/.github/workflows/output_diff.yml
@@ -50,11 +50,12 @@ jobs:
         working-directory: main
 
       - name: 'Execute prettier and remove ts-expect-error on PR dist'
-        run: sed '/@ts-expect-error/d' dist/immutable.es.js | npx prettier --parser=babel > dist/immutable.es.prettier.js
+        run: npx terser dist/immutable.es.js --comments false | npx prettier --parser=babel > dist/immutable.es.prettier.js
+
         working-directory: pr
 
       - name: 'Execute prettier main dist'
-        run: sed '/@ts-expect-error/d' dist/immutable.es.js | npx prettier --parser=babel > dist/immutable.es.prettier.js
+        run: npx terser dist/immutable.es.js --comments false | npx prettier --parser=babel > dist/immutable.es.prettier.js
         working-directory: main
 
       - name: 'Output diff'

diff --git a/__tests__/MultiRequire.js b/__tests__/MultiRequire.js
@@ -1,10 +1,8 @@
-// eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef
-const Immutable1 = require('../src/Immutable');
+import * as Immutable1 from '../src/Immutable';
 
 jest.resetModules();
 
-// eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef
-const Immutable2 = require('../src/Immutable');
+const Immutable2 = jest.requireActual('../src/Immutable');
 
 describe('MultiRequire', () => {
   it('might require two different instances of Immutable', () => {

diff --git a/eslint.config.mjs b/eslint.config.mjs
@@ -21,6 +21,7 @@ export default tseslint.config(
   { languageOptions: { globals: globals.browser } },
   pluginJs.configs.recommended,
   importPlugin.flatConfigs.recommended,
+  importPlugin.flatConfigs.typescript,
   ...tseslint.configs.recommended,
 
   {
@@ -48,14 +49,6 @@ export default tseslint.config(
     },
   },
 
-  {
-    files: ['**/*.{ts,tsx}'],
-    extends: [
-      importPlugin.flatConfigs.recommended,
-      importPlugin.flatConfigs.typescript,
-    ],
-  },
-
   {
     files: ['src/*'],
     rules: {

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -63,7 +63,7 @@
     "lint:format": "prettier --check \"{__tests__,src,type-definitions,website/src,perf,resources}/**/*{.js,.mjs,.ts,.tsx,.flow,.css}\"",
     "lint:js": "eslint",
     "type-check": "run-s type-check:*",
-    "type-check:ts": "tsc --project type-definitions/tsconfig.json && tsc --project __tests__/tsconfig.json",
+    "type-check:ts": "tsc --project tsconfig.src.json && tsc --project type-definitions/tsconfig.json && tsc --project __tests__/tsconfig.json",
     "type-check:flow": "flow check type-definitions/flow-tests --include-warnings",
     "build": "run-s build:*",
     "build:clean": "rimraf dist",
@@ -87,6 +87,7 @@
     "@rollup/plugin-commonjs": "28.0.2",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@size-limit/esbuild-why": "^8.2.6",
     "@size-limit/preset-small-lib": "^8.2.6",
     "@types/jest": "^29.0.0",
@@ -121,6 +122,7 @@
     "rollup": "4.34.8",
     "size-limit": "^8.2.6",
     "transducers-js": "0.4.174",
+    "tslib": "^2.8.1",
     "tstyche": "^3.5",
     "typescript": "5.7",
     "typescript-eslint": "^8.24.0"

diff --git a/resources/jestPreprocessor.js b/resources/jestPreprocessor.js
@@ -22,12 +22,13 @@ function transpileJavaScript(src, path) {
     const buble = require('@rollup/plugin-buble');
     const commonjs = require('@rollup/plugin-commonjs');
     const json = require('@rollup/plugin-json');
+    const typescript = require('@rollup/plugin-typescript');
 
     // same input options as in rollup-config.js
     const inputOptions = {
       input: path,
       onwarn: () => {},
-      plugins: [commonjs(), json(), buble()],
+      plugins: [commonjs(), json(), typescript(), buble()],
     };
 
     const bundle = await rollup.rollup(inputOptions);
@@ -56,11 +57,6 @@ function transpileJavaScript(src, path) {
 
 module.exports = {
   process(src, path) {
-    if (path.endsWith('__tests__/MultiRequire.js')) {
-      // exit early for multi-require as we explicitly want to have several instances
-      return { code: src };
-    }
-
     if (path.endsWith('.ts') || path.endsWith('.tsx')) {
       return { code: transpileTypeScript(src, path) };
     }

diff --git a/resources/rollup-config.mjs b/resources/rollup-config.mjs
@@ -3,6 +3,8 @@ import buble from '@rollup/plugin-buble';
 import commonjs from '@rollup/plugin-commonjs';
 import json from '@rollup/plugin-json';
 import terser from '@rollup/plugin-terser';
+// TODO replace @rollup/plugin-typescript with babel after babel migration
+import typescript from '@rollup/plugin-typescript';
 import copyright from './copyright.mjs';
 
 const SRC_DIR = path.resolve('src');
@@ -11,7 +13,7 @@ const DIST_DIR = path.resolve('dist');
 export default [
   {
     input: path.join(SRC_DIR, 'Immutable.js'),
-    plugins: [commonjs(), json(), buble()],
+    plugins: [commonjs(), json(), typescript(), buble()],
     output: [
       // umd build
       {

diff --git a/src/is.js → src/is.ts b/src/is.js → src/is.ts
@@ -54,7 +54,7 @@ import { isValueObject } from './predicates/isValueObject';
  * All Immutable collections are Value Objects: they implement `equals()`
  * and `hashCode()`.
  */
-export function is(valueA, valueB) {
+export function is(valueA: unknown, valueB: unknown): boolean {
   if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
     return true;
   }

diff --git a/src/predicates/isAssociative.js b/src/predicates/isAssociative.js
diff --git a/src/predicates/isAssociative.ts b/src/predicates/isAssociative.ts
@@ -0,0 +1,25 @@
+import { isKeyed } from './isKeyed';
+import { isIndexed } from './isIndexed';
+import type { Collection } from '../../type-definitions/immutable';
+
+/**
+ * True if `maybeAssociative` is either a Keyed or Indexed Collection.
+ *
+ * ```js
+ * import { isAssociative, Map, List, Stack, Set } from 'immutable';
+ *
+ * isAssociative([]); // false
+ * isAssociative({}); // false
+ * isAssociative(Map()); // true
+ * isAssociative(List()); // true
+ * isAssociative(Stack()); // true
+ * isAssociative(Set()); // false
+ * ```
+ */
+export function isAssociative(
+  maybeAssociative: unknown
+): maybeAssociative is
+  | Collection.Keyed<unknown, unknown>
+  | Collection.Indexed<unknown> {
+  return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
+}
diff --git a/src/predicates/isCollection.js b/src/predicates/isCollection.js
diff --git a/src/predicates/isCollection.ts b/src/predicates/isCollection.ts
@@ -0,0 +1,27 @@
+import type { Collection } from '../../type-definitions/immutable';
+
+// Note: value is unchanged to not break immutable-devtools.
+export const IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';
+
+/**
+ * True if `maybeCollection` is a Collection, or any of its subclasses.
+ *
+ * ```js
+ * import { isCollection, Map, List, Stack } from 'immutable';
+ *
+ * isCollection([]); // false
+ * isCollection({}); // false
+ * isCollection(Map()); // true
+ * isCollection(List()); // true
+ * isCollection(Stack()); // true
+ * ```
+ */
+export function isCollection(
+  maybeCollection: unknown
+): maybeCollection is Collection<unknown, unknown> {
+  return Boolean(
+    maybeCollection &&
+      // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection`
+      maybeCollection[IS_COLLECTION_SYMBOL]
+  );
+}
diff --git a/src/predicates/isImmutable.js b/src/predicates/isImmutable.js
diff --git a/src/predicates/isImmutable.ts b/src/predicates/isImmutable.ts
@@ -0,0 +1,24 @@
+import type { Collection, Record } from '../../type-definitions/immutable';
+import { isCollection } from './isCollection';
+import { isRecord } from './isRecord';
+
+/**
+ * True if `maybeImmutable` is an Immutable Collection or Record.
+ *
+ * Note: Still returns true even if the collections is within a `withMutations()`.
+ *
+ * ```js
+ * import { isImmutable, Map, List, Stack } from 'immutable';
+ * isImmutable([]); // false
+ * isImmutable({}); // false
+ * isImmutable(Map()); // true
+ * isImmutable(List()); // true
+ * isImmutable(Stack()); // true
+ * isImmutable(Map().asMutable()); // true
+ * ```
+ */
+export function isImmutable(
+  maybeImmutable: unknown
+): maybeImmutable is Collection<unknown, unknown> | Record<object> {
+  return isCollection(maybeImmutable) || isRecord(maybeImmutable);
+}
diff --git a/src/predicates/isIndexed.js b/src/predicates/isIndexed.js
diff --git a/src/predicates/isIndexed.ts b/src/predicates/isIndexed.ts
@@ -0,0 +1,27 @@
+import type { Collection } from '../../type-definitions/immutable';
+
+export const IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
+
+/**
+ * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses.
+ *
+ * ```js
+ * import { isIndexed, Map, List, Stack, Set } from 'immutable';
+ *
+ * isIndexed([]); // false
+ * isIndexed({}); // false
+ * isIndexed(Map()); // false
+ * isIndexed(List()); // true
+ * isIndexed(Stack()); // true
+ * isIndexed(Set()); // false
+ * ```
+ */
+export function isIndexed(
+  maybeIndexed: unknown
+): maybeIndexed is Collection.Indexed<unknown> {
+  return Boolean(
+    maybeIndexed &&
+      // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed`
+      maybeIndexed[IS_INDEXED_SYMBOL]
+  );
+}
diff --git a/src/predicates/isKeyed.js b/src/predicates/isKeyed.js
diff --git a/src/predicates/isKeyed.ts b/src/predicates/isKeyed.ts
@@ -0,0 +1,26 @@
+import type { Collection } from '../../type-definitions/immutable';
+
+export const IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';
+
+/**
+ * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses.
+ *
+ * ```js
+ * import { isKeyed, Map, List, Stack } from 'immutable';
+ *
+ * isKeyed([]); // false
+ * isKeyed({}); // false
+ * isKeyed(Map()); // true
+ * isKeyed(List()); // false
+ * isKeyed(Stack()); // false
+ * ```
+ */
+export function isKeyed(
+  maybeKeyed: unknown
+): maybeKeyed is Collection.Keyed<unknown, unknown> {
+  return Boolean(
+    maybeKeyed &&
+      // @ts-expect-error: maybeKeyed is typed as `{}`, need to change in 6.0 to `maybeKeyed && typeof maybeKeyed === 'object' && IS_KEYED_SYMBOL in maybeKeyed`
+      maybeKeyed[IS_KEYED_SYMBOL]
+  );
+}
diff --git a/src/predicates/isList.js b/src/predicates/isList.js
diff --git a/src/predicates/isList.ts b/src/predicates/isList.ts
@@ -0,0 +1,14 @@
+import type { List } from '../../type-definitions/immutable';
+
+export const IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';
+
+/**
+ * True if `maybeList` is a List.
+ */
+export function isList(maybeList: unknown): maybeList is List<unknown> {
+  return Boolean(
+    maybeList &&
+      // @ts-expect-error: maybeList is typed as `{}`, need to change in 6.0 to `maybeList && typeof maybeList === 'object' && IS_LIST_SYMBOL in maybeList`
+      maybeList[IS_LIST_SYMBOL]
+  );
+}
diff --git a/src/predicates/isMap.js b/src/predicates/isMap.js