Jsonify: Allow partial types

source/jsonify.d.ts

@@ -70,6 +70,6 @@ type Jsonify<T> =
 						? (() => J) extends (() => JsonValue) // Is J assignable to JsonValue?
 							? J // Then T is Jsonable and its Jsonable value is J
 							: never // Not Jsonable because its toJSON() method does not return JsonValue
-						: {[P in keyof T]: Jsonify<T[P]>} // It's an object: recursive call for its children
+						: {[P in keyof T]: Jsonify<Required<T>[P]>} // It's an object: recursive call for its children
 					: never // Otherwise any other non-object is removed
 		: never; // Otherwise non-JSONable type union was found not empty

test-d/jsonify.ts

@@ -1,4 +1,4 @@
-import {expectAssignable, expectNotAssignable} from 'tsd';
+import {expectAssignable, expectNotAssignable, expectType} from 'tsd';
 import {Jsonify, JsonValue} from '..';
 
 interface A {
@@ -122,3 +122,30 @@ class NonJsonWithInvalidToJSON {
 const nonJsonWithInvalidToJSON = new NonJsonWithInvalidToJSON();
 expectNotAssignable<JsonValue>(nonJsonWithInvalidToJSON);
 expectNotAssignable<JsonValue>(nonJsonWithInvalidToJSON.toJSON());
+
+// Test that optional type members are not discarded wholesale.
+interface OptionalPrimitive {
+	a?: string;
+}
+
+interface OptionalTypeUnion {
+	a?: string | (() => any);
+}
+
+interface OptionalFunction {
+	a?: () => any;
+}
+
+interface NonOptionalTypeUnion {
+	a: string | undefined;
+}
+
+declare const jsonifiedOptionalPrimitive: Jsonify<OptionalPrimitive>;
+declare const jsonifiedOptionalTypeUnion: Jsonify<OptionalTypeUnion>;
+declare const jsonifiedOptionalFunction: Jsonify<OptionalFunction>;
+declare const jsonifiedNonOptionalTypeUnion: Jsonify<NonOptionalTypeUnion>;
+
+expectType<{a?: string}>(jsonifiedOptionalPrimitive);
+expectType<{a?: never}>(jsonifiedOptionalTypeUnion);
+expectType<{a?: never}>(jsonifiedOptionalFunction);
+expectType<{a: never}>(jsonifiedNonOptionalTypeUnion);