Allow readonly string arrays in types.enumeration (#2059)

* feat: Allow readonly string arrays in types.enumeration

* fix type a bit

Author: jamonholmgren

packages/mobx-state-tree/__tests__/core/enum.test.ts

@@ -46,3 +46,29 @@ test("should support optional enums inside a model", () => {
     const l = TrafficLight.create({})
     expect(l.color).toBe(ColorEnum.Orange)
 })
+test("should support plain string[] arrays", () => {
+    const colorOptions: string[] = ["Red", "Orange", "Green"]
+    const TrafficLight = types.model({ color: types.enumeration(colorOptions) })
+    const l = TrafficLight.create({ color: "Orange" })
+    unprotect(l)
+    l.color = "Red"
+    expect(TrafficLight.describe()).toBe('{ color: ("Red" | "Orange" | "Green") }')
+    if (process.env.NODE_ENV !== "production") {
+        expect(() => (l.color = "Blue" as any)).toThrowError(
+            /Error while converting `"Blue"` to `"Red" | "Orange" | "Green"`/
+        )
+    }
+})
+test("should support readonly enums as const", () => {
+    const colorOptions = ["Red", "Orange", "Green"] as const
+    const TrafficLight = types.model({ color: types.enumeration(colorOptions) })
+    const l = TrafficLight.create({ color: "Orange" })
+    unprotect(l)
+    l.color = "Red"
+    expect(TrafficLight.describe()).toBe('{ color: ("Red" | "Orange" | "Green") }')
+    if (process.env.NODE_ENV !== "production") {
+        expect(() => (l.color = "Blue" as any)).toThrowError(
+            /Error while converting `"Blue"` to `"Red" | "Orange" | "Green"`/
+        )
+    }
+})

packages/mobx-state-tree/src/types/utility-types/enumeration.ts

@@ -1,14 +1,16 @@
 import { ISimpleType, union, literal, assertIsString, devMode } from "../../internal"
 
 /** @hidden */
-export type UnionStringArray<T extends string[]> = T[number]
+export type UnionStringArray<T extends readonly string[]> = T[number]
 
-// strongly typed enumeration forms for plain string arrays (when passed directly to the function)
-// with these overloads we also get correct typing for native TS string enums when we use Object.values(Enum) as Enum[] as options
-// also these overloads make types.enumeration<Enum>(Object.values(Enum)) possible
-// the only case where this doesn't work is when passing to the function an arrays variable, for these cases
-// it will just fallback and assume the type is a generic string
-export function enumeration<T extends string>(options: T[]): ISimpleType<UnionStringArray<T[]>>
+// strongly typed enumeration forms for plain and readonly string arrays (when passed directly to the function).
+// with these overloads, we get correct typing for native TS string enums when we use Object.values(Enum) as Enum[] as options.
+// these overloads also allow both mutable and immutable arrays, making types.enumeration<Enum>(Object.values(Enum)) possible.
+// the only case where this doesn't work is when passing to the function an array variable with a mutable type constraint;
+// for these cases, it will just fallback and assume the type is a generic string.
+export function enumeration<T extends readonly string[]>(
+    options: T
+): ISimpleType<UnionStringArray<T>>
 export function enumeration<T extends string>(
     name: string,
     options: T[]