Jsonify: Handle unknown as JsonValue (#1206)

Author: GerkinDev

source/internal/keys.d.ts

@@ -1,5 +1,6 @@
 import type {IsAny} from '../is-any.d.ts';
 import type {IsLiteral} from '../is-literal.d.ts';
+import type {IsUnknown} from '../is-unknown.d.ts';
 import type {ToString} from './string.d.ts';
 
 // Returns `never` if the key or property is not jsonable without testing whether the property is required or optional otherwise return the key.
@@ -25,7 +26,7 @@ export type FilterDefinedKeys<T extends object> = Exclude<
 	{
 		[Key in keyof T]: IsAny<T[Key]> extends true
 			? Key
-			: undefined extends T[Key]
+			: IsUnknown<T[Key]> extends true ? Key : undefined extends T[Key]
 				? never
 				: T[Key] extends undefined
 					? never

source/jsonify.d.ts

@@ -18,9 +18,11 @@ type UndefinedToNull<T> = T extends undefined ? null : T;
 type JsonifyList<T extends UnknownArray> = T extends readonly []
 	? []
 	: T extends readonly [infer F, ...infer R]
-		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
+		? [F, ...R] extends T // With TS 5.8.3, if `string[] & ['foo']`, `R` is `unknown[]` here, making the infered types neq to the original one
+			? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
+			: [NeverToNull<Jsonify<F>>]
 		: IsUnknown<T[number]> extends true
-			? []
+			? JsonValue[]
 			: Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
 
 type FilterJsonableKeys<T extends object> = {
@@ -119,4 +121,6 @@ export type Jsonify<T> = IsAny<T> extends true
 											? JsonifyList<T>
 											: T extends object
 												? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
-												: never; // Otherwise any other non-object is removed
+												: IsUnknown<T> extends true
+													? JsonValue
+													: never; // Otherwise any other non-object is removed

test-d/jsonify.ts

@@ -369,3 +369,22 @@ expectType<typeof nestedObjectWithNameProperty>(
 // Regression test for https://github.com/sindresorhus/type-fest/issues/629
 declare const readonlyTuple: Jsonify<readonly [1, 2, 3]>;
 expectType<[1, 2, 3]>(readonlyTuple);
+
+// `unknown` values
+declare const unknownValue: Jsonify<unknown>;
+declare const unknownArray: Jsonify<unknown[]>;
+declare const unknownTuple: Jsonify<[unknown, unknown]>;
+declare const objectWithUnknownValue: Jsonify<{key: unknown}>;
+expectType<JsonValue>(unknownValue);
+expectAssignable<Jsonify<unknown>>('foo');
+expectAssignable<Jsonify<unknown>>(['foo']);
+expectNotAssignable<Jsonify<unknown>>(new Date());
+expectType<JsonValue[]>(unknownArray);
+expectAssignable<Jsonify<unknown[]>>(['foo']);
+expectNotAssignable<Jsonify<unknown[]>>([new Date()]);
+expectType<[JsonValue, JsonValue]>(unknownTuple);
+expectAssignable<Jsonify<[unknown, unknown]>>(['foo', 'foo']);
+expectNotAssignable<Jsonify<[unknown, unknown]>>([new Date(), new Date()]);
+expectType<{key: JsonValue}>(objectWithUnknownValue);
+expectAssignable<Jsonify<{key: unknown}>>({key: []});
+expectNotAssignable<Jsonify<{key: unknown}>>({key: new Date()});