From 025f6e9db5db7ae3ee5697595fb7eb0fce1e3998 Mon Sep 17 00:00:00 2001
From: Emiya <2914034404@qq.com>
Date: Sat, 30 Sep 2023 22:32:23 +0800
Subject: [PATCH] `Jsonify`: Fix handling of arrays (#673)

---
 source/jsonify.d.ts | 26 +++++++++++++-------------
 test-d/jsonify.ts   | 17 ++++++++++++-----
 2 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/source/jsonify.d.ts b/source/jsonify.d.ts
index 1894ee250..d429e2ddc 100644
--- a/source/jsonify.d.ts
+++ b/source/jsonify.d.ts
@@ -3,24 +3,24 @@ import type {EmptyObject} from './empty-object';
 import type {UndefinedToOptional} from './internal';
 import type {IsAny} from './is-any';
 import type {IsNever} from './is-never';
+import type {IsUnknown} from './is-unknown';
 import type {NegativeInfinity, PositiveInfinity} from './numeric';
 import type {TypedArray} from './typed-array';
+import type {WritableDeep} from './writable-deep';
 
 // Note: The return value has to be `any` and not `unknown` so it can match `void`.
 type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
 
-type FilterNonNever<T extends unknown[]> = T extends [infer F, ...infer R]
-	? IsNever<F> extends true
-		? FilterNonNever<R>
-		: [F, ...FilterNonNever<R>]
-	: IsNever<T[number]> extends true
-		? []
-		: T;
+type NeverToNull<T> = IsNever<T> extends true ? null : T;
 
 // Handles tuples and arrays
-type JsonifyList<T extends unknown[]> = T extends [infer F, ...infer R]
-	? FilterNonNever<[Jsonify<F>, ...JsonifyList<R>]>
-	: Array<Jsonify<T[number]>>;
+type JsonifyList<T extends unknown[]> = T extends []
+	? []
+	: T extends [infer F, ...infer R]
+		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
+		: IsUnknown<T[number]> extends true
+			? []
+			: Array<T[number] extends NotJsonable ? null : Jsonify<T[number]>>;
 
 type FilterJsonableKeys<T extends object> = {
 	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
@@ -116,10 +116,10 @@ export type Jsonify<T> = IsAny<T> extends true
 											: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
 										: T extends []
 											? []
-											: T extends [unknown, ...unknown[]]
+											: T extends unknown[]
 												? JsonifyList<T>
-												: T extends ReadonlyArray<infer U>
-													? Array<U extends NotJsonable ? null : Jsonify<U>>
+												: T extends readonly unknown[]
+													? JsonifyList<WritableDeep<T>>
 													: T extends object
 														? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
 														: never; // Otherwise any other non-object is removed
diff --git a/test-d/jsonify.ts b/test-d/jsonify.ts
index b642a2a66..2c263dd1f 100644
--- a/test-d/jsonify.ts
+++ b/test-d/jsonify.ts
@@ -222,6 +222,9 @@ expectType<[string, string]>(tupleJson);
 declare const tupleRestJson: Jsonify<[string, ...Date[]]>;
 expectType<[string, ...string[]]>(tupleRestJson);
 
+declare const mixTupleJson: Jsonify<['1', (_: any) => void, 2]>;
+expectType<['1', null, 2]>(mixTupleJson);
+
 declare const tupleStringJson: Jsonify<string[] & ['some value']>;
 expectType<['some value']>(tupleStringJson);
 
@@ -334,10 +337,14 @@ declare const nestedObjectWithNameProperty: {
 		name: string;
 	};
 };
-declare const jsonifiedNestedObjectWithNameProperty: Jsonify<typeof nestedObjectWithNameProperty>;
+declare const jsonifiedNestedObjectWithNameProperty: Jsonify<
+	typeof nestedObjectWithNameProperty
+>;
 
-expectType<typeof nestedObjectWithNameProperty>(jsonifiedNestedObjectWithNameProperty);
+expectType<typeof nestedObjectWithNameProperty>(
+	jsonifiedNestedObjectWithNameProperty,
+);
 
-/// #629
-// declare const readonlyTuple: Jsonify<readonly [1, 2, 3]>;
-// expectType<readonly [1, 2, 3]>(readonlyTuple);
+// Regression test for https://github.com/sindresorhus/type-fest/issues/629
+declare const readonlyTuple: Jsonify<readonly [1, 2, 3]>;
+expectType<[1, 2, 3]>(readonlyTuple);