Fix syntax for specifying types in certain JSDoc codeblocks (#1362)

Author: som-sm

source/array-splice.d.ts

@@ -50,10 +50,10 @@ Split the given array `T` by the given `SplitIndex`.
 @example
 ```
 type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
+//=> [[1, 2], [3, 4]];
 
 type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
+//=> [[], [1, 2, 3, 4]];
 ```
 */
 type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =

source/pick-deep.d.ts

@@ -5,6 +5,7 @@ import type {Paths} from './paths.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {UnionToIntersection} from './union-to-intersection.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {SimplifyDeep} from './simplify-deep.d.ts';
 
 /**
 Pick properties from a deeply-nested object.
@@ -36,24 +37,15 @@ type Configuration = {
 };
 
 type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
-// type NameConfig = {
-// 	userConfig: {
-// 		name: string;
-// 	}
-// };
+//=> {userConfig: {name: string}}
 
 // Supports optional properties
 type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
-// type User = {
-// 	userConfig?: {
-// 		name?: string;
-// 		age?: number;
-// 	};
-// };
+//=> {userConfig?: {name?: string; age?: number}}
 
 // Supports array
 type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
-// type AddressConfig = {
+//=> {
 // 	userConfig: {
 // 		address: [{
 // 			city1: string;
@@ -64,14 +56,7 @@ type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
 
 // Supports recurse into array
 type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
-// type Street = {
-// 	userConfig: {
-// 		address: [
-// 			unknown,
-// 			{street2: string}
-// 		];
-// 	};
-// }
+//=> {userConfig: {address: [unknown, {street2: string}]}}
 ```
 
 @category Object
@@ -86,7 +71,7 @@ export type PickDeep<T, PathUnion extends Paths<T>> =
 			}[PathUnion]
 			>
 			: T extends object
-				? Simplify<UnionToIntersection<{
+				? SimplifyDeep<UnionToIntersection<{
 					[P in PathUnion]: InternalPickDeep<T, P>;
 				}[PathUnion]>>
 				: never;

source/set-non-nullable.d.ts

@@ -15,26 +15,19 @@ type Foo = {
 	c?: boolean | null;
 };
 
+// Note: In the following example, `c` can no longer be `null`, but it's still optional.
 type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
-// type SomeNonNullable = {
-// 	a: number | null;
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
+//=> {a: null | number; b: string; c?: boolean}
 
 type AllNonNullable = SetNonNullable<Foo>;
-// type AllNonNullable = {
-// 	a: number; // Can no longer be null.
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
+//=> {a: number; b: string; c?: boolean}
 ```
 
 @category Object
 */
 export type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = {
 	[Key in keyof BaseType]: Key extends Keys
-		? NonNullable<BaseType[Key]>
+		? BaseType[Key] & {} // `& {}` is used instead of `NonNullable<BaseType[Key]>` because `NonNullable` doesn't get simplified.
 		: BaseType[Key];
 };
 

source/set-optional.d.ts

@@ -18,11 +18,7 @@ type Foo = {
 };
 
 type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
+//=> {a: number; b?: string; c?: boolean}
 ```
 
 @category Object

source/set-readonly.d.ts

@@ -18,11 +18,7 @@ type Foo = {
 };
 
 type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
-// type SomeReadonly = {
-// 	a: number;
-// 	readonly b: string; // Was already readonly and still is.
-// 	readonly c: boolean; // Is now readonly.
-// }
+//=> {a: number; readonly b: string; readonly c: boolean}
 ```
 
 @category Object

source/set-required.d.ts

@@ -21,11 +21,7 @@ type Foo = {
 };
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
+//=> {a?: number; b: string; c: boolean}
 
 // Set specific indices in an array to be required.
 type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;

source/spread.d.ts

@@ -41,11 +41,7 @@ const bar = {c: false};
 const fooBar = {...foo, ...bar};
 
 type FooBar = Spread<Foo, Bar>;
-// type FooBar = {
-// 	a: number;
-// 	b?: string | number | undefined;
-// 	c: boolean;
-// }
+//=> {a: number; b?: string | number; c: boolean}
 
 declare function baz(argument: FooBar): void;
 

source/writable.d.ts

@@ -37,11 +37,7 @@ writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b"
 writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
 
 type SomeWritable = Writable<Foo, 'b' | 'c'>;
-// type SomeWritable = {
-// 	readonly a: number;
-// 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
-// 	c: boolean; // It's now writable.
-// }
+//=> {readonly a: number; b: readonly string[]; c: boolean}
 
 // Also supports array
 const readonlyArray: readonly number[] = [1, 2, 3];

test-d/pick-deep.ts

@@ -71,7 +71,7 @@ declare const genericTest: PickDeep<GenericType<number>, 'genericKey'>;
 expectType<{genericKey: number}>(genericTest);
 
 declare const union: PickDeep<Testing, 'object.number' | 'object.string'>;
-expectType<{object: {number: number} & {string: string}}>(union);
+expectType<{object: {number: number; string: string}}>(union);
 
 declare const optional: PickDeep<Testing, 'optionalObject.optionalString'>;
 expectType<{optionalObject?: {optionalString?: string}}>(optional);