WritableDeep: Fix array handling (#724)

Emiyaaaaa · web-flow · commit 9baccc358c7c · 2023-10-24T03:08:09.000+07:00
diff --git a/source/writable-deep.d.ts b/source/writable-deep.d.ts
@@ -38,27 +38,47 @@ export type WritableDeep<T> = T extends BuiltIns
 			: HasMultipleCallSignatures<T> extends true
 				? T
 				: ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
-		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
-			? WritableMapDeep<KeyType, ValueType>
-			: T extends Readonly<ReadonlySet<infer ItemType>>
-				? WritableSetDeep<ItemType>
-				: T extends object
-					? WritableObjectDeep<T>
-					: unknown;
+		: T extends ReadonlyMap<unknown, unknown>
+			? WritableMapDeep<T>
+			: T extends ReadonlySet<unknown>
+				? WritableSetDeep<T>
+				: T extends readonly unknown[]
+					? WritableArrayDeep<T>
+					: T extends object
+						? WritableObjectDeep<T>
+						: unknown;
 
 /**
 Same as `WritableDeep`, but accepts only `Map`s as inputs. Internal helper for `WritableDeep`.
 */
-type WritableMapDeep<KeyType, ValueType> = {} & Writable<Map<WritableDeep<KeyType>, WritableDeep<ValueType>>>;
+type WritableMapDeep<MapType extends ReadonlyMap<unknown, unknown>> =
+	MapType extends ReadonlyMap<infer KeyType, infer ValueType>
+		? Map<WritableDeep<KeyType>, WritableDeep<ValueType>>
+		: MapType; // Should not heppen
 
 /**
 Same as `WritableDeep`, but accepts only `Set`s as inputs. Internal helper for `WritableDeep`.
 */
-type WritableSetDeep<ItemType> = {} & Writable<Set<WritableDeep<ItemType>>>;
+type WritableSetDeep<SetType extends ReadonlySet<unknown>> =
+	SetType extends ReadonlySet<infer ItemType>
+		? Set<WritableDeep<ItemType>>
+		: SetType; // Should not heppen
 
 /**
 Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper for `WritableDeep`.
 */
 type WritableObjectDeep<ObjectType extends object> = {
 	-readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>
 };
+
+/**
+Same as `WritableDeep`, but accepts only `Array`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableArrayDeep<ArrayType extends readonly unknown[]> =
+	ArrayType extends readonly [] ? []
+		: ArrayType extends readonly [...infer U, infer V] ? [...WritableArrayDeep<U>, WritableDeep<V>]
+			: ArrayType extends readonly [infer U, ...infer V] ? [WritableDeep<U>, ...WritableArrayDeep<V>]
+				: ArrayType extends ReadonlyArray<infer U> ? Array<WritableDeep<U>>
+					: ArrayType extends Array<infer U> ? Array<WritableDeep<U>>
+						: ArrayType;
+
diff --git a/test-d/writable-deep.ts b/test-d/writable-deep.ts
@@ -1,6 +1,7 @@
 import {expectType, expectError, expectAssignable} from 'tsd';
-import type {ReadonlyDeep, Writable, WritableDeep} from '../index';
+import type {JsonValue, Opaque, ReadonlyDeep, WritableDeep} from '../index';
 import type {WritableObjectDeep} from '../source/writable-deep';
+import {type tag} from '../source/opaque';
 
 type Overloaded = {
 	(foo: number): string;
@@ -16,6 +17,17 @@ type NamespaceWithOverload = Overloaded & {
 	readonly baz: readonly boolean[];
 };
 
+type OpaqueObjectData = {readonly a: number[]} | {readonly b: string};
+type OpaqueObject = Opaque<OpaqueObjectData, {readonly token: unknown}>;
+
+type ReadonlyJsonValue =
+  | {readonly [k: string]: ReadonlyJsonValue}
+  | readonly ReadonlyJsonValue[]
+  | number
+  | string
+  | boolean
+  | null;
+
 const data = {
 	object: {
 		foo: 'bar',
@@ -35,14 +47,21 @@ const data = {
 	map: new Map<string, string>(),
 	set: new Set<string>(),
 	array: ['foo'],
+	emptyTuple: [] as [],
 	tuple: ['foo'] as ['foo'],
+	multiItemTuple: [{a: ''}, {b: 1}] as [{a: string}, {b: number}],
+	spreadTuple: ['foo'] as [...string[]],
+	trailingSpreadTuple: ['foo', 1] as [string, ...number[]],
+	leadingSpreadTuple: ['foo', 1] as [...string[], number],
 	readonlyMap: new Map<string, string>() as ReadonlyMap<string, string>,
 	readonlySet: new Set<string>() as ReadonlySet<string>,
 	readonlyArray: ['foo'] as readonly string[],
 	readonlyTuple: ['foo'] as const,
+	json: [{x: true}] as JsonValue,
+	opaqueObj: {a: [3]} as OpaqueObject, // eslint-disable-line @typescript-eslint/consistent-type-assertions
 };
 
-const readonlyData: Readonly<typeof data> = data;
+const readonlyData: ReadonlyDeep<typeof data> = data;
 
 let writableData: WritableDeep<typeof readonlyData>;
 expectError(writableData = readonlyData);
@@ -63,14 +82,21 @@ expectType<null>(writableData.null);
 expectType<undefined>(writableData.undefined);
 expectType<Date>(writableData.date);
 expectType<RegExp>(writableData.regExp);
-expectType<Writable<Map<string, string>>>(writableData.map);
-expectType<Writable<Set<string>>>(writableData.set);
+expectType<Map<string, string>>(writableData.map);
+expectType<Set<string>>(writableData.set);
 expectType<string[]>(writableData.array);
+expectType<[]>(writableData.emptyTuple);
 expectType<['foo']>(writableData.tuple);
-expectType<Writable<Map<string, string>>>(writableData.readonlyMap);
-expectType<Writable<Set<string>>>(writableData.readonlySet);
+expectType<[{a: string}, {b: number}]>(writableData.multiItemTuple);
+expectType<[...string[]]>(writableData.spreadTuple);
+expectType<[string, ...number[]]>(writableData.trailingSpreadTuple);
+expectType<[...string[], number]>(writableData.leadingSpreadTuple);
+expectType<Map<string, string>>(writableData.readonlyMap);
+expectType<Set<string>>(writableData.readonlySet);
 expectType<string[]>(writableData.readonlyArray);
 expectType<['foo']>(writableData.readonlyTuple);
+expectAssignable<ReadonlyJsonValue>(writableData.json);
+expectAssignable<Opaque<WritableDeep<OpaqueObjectData>, WritableDeep<OpaqueObject[typeof tag]>>>(writableData.opaqueObj);
 
 expectType<((foo: number) => string) & WritableObjectDeep<Namespace>>(writableData.namespace);
 expectType<string>(writableData.namespace(1));
