immer/__tests__/immutable.ts at main · immerjs/immer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import {assert, _} from "./spec_ts"
import {produce, Immutable, castImmutable} from "../src/immer"

test("types are ok", () => {
	// array in tuple
	{
		let val = _ as Immutable<[string[], 1]>
		assert(val, _ as readonly [ReadonlyArray<string>, 1])
	}

	// tuple in array
	{
		let val = _ as Immutable<[string, 1][]>
		assert(val, _ as ReadonlyArray<readonly [string, 1]>)
	}

	// tuple in tuple
	{
		let val = _ as Immutable<[[string, 1], 1]>
		assert(val, _ as readonly [readonly [string, 1], 1])
	}

	// array in array
	{
		let val = _ as Immutable<string[][]>
		assert(val, _ as ReadonlyArray<ReadonlyArray<string>>)
	}

	// tuple in object
	{
		let val = _ as Immutable<{a: [string, 1]}>
		assert(val, _ as {readonly a: readonly [string, 1]})
	}

	// object in tuple
	{
		let val = _ as Immutable<[{a: string}, 1]>
		assert(val, _ as readonly [{readonly a: string}, 1])
	}

	// array in object
	{
		let val = _ as Immutable<{a: string[]}>
		assert(val, _ as {readonly a: ReadonlyArray<string>})
	}

	// object in array
	{
		let val = _ as Immutable<Array<{a: string}>>
		assert(val, _ as ReadonlyArray<{readonly a: string}>)
	}

	// object in object
	{
		let val = _ as Immutable<{a: {b: string}}>
		assert(val, _ as {readonly a: {readonly b: string}})
	}

	// Map
	{
		let val = _ as Immutable<Map<string, string>>
		assert(val, _ as ReadonlyMap<string, string>)
	}

	// Already immutable Map
	{
		let val = _ as Immutable<ReadonlyMap<string, string>>
		assert(val, _ as ReadonlyMap<string, string>)
	}

	// object in Map
	{
		let val = _ as Immutable<Map<{a: string}, {b: string}>>
		assert(val, _ as ReadonlyMap<{readonly a: string}, {readonly b: string}>)
	}

	// Set
	{
		let val = _ as Immutable<Set<string>>
		assert(val, _ as ReadonlySet<string>)
	}

	// Already immutable Set
	{
		let val = _ as Immutable<ReadonlySet<string>>
		assert(val, _ as ReadonlySet<string>)
	}

	// object in Set
	{
		let val = _ as Immutable<Set<{a: string}>>
		assert(val, _ as ReadonlySet<{readonly a: string}>)
	}

	expect(true).toBe(true)
})

test("#381 produce immutable state", () => {
	const someState = {
		todos: [
			{
				done: false
			}
		]
	}

	const immutable = castImmutable(produce(someState, _draft => {}))
	assert(
		immutable,
		_ as {readonly todos: ReadonlyArray<{readonly done: boolean}>}
	)
})

test("castImmutable preserves a value", () => {
	const x = {}
	expect(castImmutable(x)).toBe(x)
})