fix: 🐛 tuple and map key immutability

Author: lrodrigues-newstore

packages/immutable/src/index.ts

@@ -1,14 +1,19 @@
-export type Immutable<T> = T extends Array<infer E>
-  ? ImmutableArray<E>
-  : T extends Map<infer K, infer V>
-    ? ImmutableMap<K, V>
-    : T extends Set<infer E>
-      ? ImmutableSet<E>
-      : T extends Record<string, infer V>
-        ? ImmutableObject<T, V>
-        : T
+export type Immutable<T> = T extends readonly [infer First, ...infer Rest]
+  ? readonly [Immutable<First>, ...ImmutableTuple<Rest>]
+  : T extends readonly (infer E)[]
+    ? ReadonlyArray<Immutable<E>>
+    : T extends Map<infer K, infer V>
+      ? ReadonlyMap<Immutable<K>, Immutable<V>>
+      : T extends Set<infer E>
+        ? ReadonlySet<Immutable<E>>
+        : T extends Record<string, infer V>
+          ? { readonly [P in keyof T]: Immutable<V> }
+          : T
 
-type ImmutableArray<T> = ReadonlyArray<Immutable<T>>
-type ImmutableObject<T, V> = { readonly [P in keyof T]: Immutable<V> }
-type ImmutableMap<K, V> = ReadonlyMap<K, Immutable<V>>
-type ImmutableSet<T> = ReadonlySet<Immutable<T>>
+// biome-ignore lint/suspicious/noExplicitAny: extend tuples of any type
+export type ImmutableTuple<T extends readonly any[]> = T extends readonly [
+  infer F,
+  ...infer R,
+]
+  ? readonly [Immutable<F>, ...ImmutableTuple<R>]
+  : readonly []

packages/immutable/test/immutable.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import type { Immutable } from '../src/index'
+
+describe('Immutable', () => {
+  it('marks nested object properties as readonly', () => {
+    type Actual = Immutable<{ foo: { bar: string } }>
+    type Expected = { readonly foo: { readonly bar: string } }
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+
+  it('transforms arrays into readonly arrays', () => {
+    type Actual = Immutable<number[]>
+    type Expected = readonly number[]
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+
+  it('keeps tuple structure while wrapping entries', () => {
+    type Actual = Immutable<[number, { label: string }]>
+    type Expected = readonly [number, Readonly<{ label: string }>]
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+
+  it('wraps map values with immutable variants', () => {
+    type Actual = Immutable<Map<{ key: string }, { value: number }>>
+    type Expected = ReadonlyMap<
+      Readonly<{ key: string }>,
+      Readonly<{ value: number }>
+    >
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+
+  it('wraps set values with immutable variants', () => {
+    type Actual = Immutable<Set<{ id: string }>>
+    type Expected = ReadonlySet<Readonly<{ id: string }>>
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+
+  it('leaves primitive values unchanged', () => {
+    type Actual = Immutable<string>
+    type Expected = string
+    expectTypeOf<Actual>().toEqualTypeOf<Expected>()
+  })
+})