type-fest 4.3.1 → 4.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.3.1",
+	"version": "4.3.3",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -77,6 +77,8 @@ npm install type-fest
 
 *Requires TypeScript >=5.1*
 
+*Works best with [`{strict: true}`](https://www.typescriptlang.org/tsconfig#strict) in your tsconfig.*
+
 ## Usage
 
 ```ts
@@ -291,10 +293,11 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 
 *If you know one of our types by a different name, add it here for discovery.*
 
+- `Prettify`- See [`Simplify`](https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts)
+- `Expand`- See [`Simplify`](https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts)
 - `PartialBy` - See [`SetOptional`](https://github.com/sindresorhus/type-fest/blob/main/source/set-optional.d.ts)
 - `RecordDeep`- See [`Schema`](https://github.com/sindresorhus/type-fest/blob/main/source/schema.d.ts)
 - `Mutable`- See [`Writable`](https://github.com/sindresorhus/type-fest/blob/main/source/writable.d.ts)
-- `Prettify`- See [`Simplify`](https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts)
 - `RequireOnlyOne` - See [`RequireExactlyOne`](https://github.com/sindresorhus/type-fest/blob/main/source/require-exactly-one.d.ts)
 - `AtMostOne` - See [`RequireOneOrNone`](https://github.com/sindresorhus/type-fest/blob/main/source/require-one-or-none.d.ts)
 

package/source/internal.d.ts

@@ -189,9 +189,16 @@ type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
 	? never
 	: Type[Key] extends symbol
 		? never
-		: [(...arguments_: any[]) => any] extends [Type[Key]]
-			? never
-			: Key;
+		/*
+		To prevent a problem where an object with only a `name` property is incorrectly treated as assignable to a function, we first check if the property is a record.
+		This check is necessary, because without it, if we don't verify whether the property is a record, an object with a type of `{name: any}` would return `never` due to its potential assignability to a function.
+		See: https://github.com/sindresorhus/type-fest/issues/657
+		*/
+		: Type[Key] extends Record<string, unknown>
+			? Key
+			: [(...arguments_: any[]) => any] extends [Type[Key]]
+				? never
+				: Key;
 
 /**
 Returns the required keys.
@@ -254,3 +261,20 @@ export type IsNull<T> = [T] extends [null] ? true : false;
 Disallows any of the given keys.
 */
 export type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+
+/**
+Returns a boolean for whether the given type is primitive value or primitive type.
+
+@example
+```
+IsPrimitive<'string'>
+//=> true
+
+IsPrimitive<string>
+//=> true
+
+IsPrimitive<Object>
+//=> false
+```
+*/
+export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;

package/source/is-literal.d.ts

@@ -1,6 +1,6 @@
 import type {Primitive} from './primitive';
 import type {Numeric} from './numeric';
-import type {IsNotFalse} from './internal';
+import type {IsNotFalse, IsPrimitive} from './internal';
 import type {IsNever} from './is-never';
 
 /**
@@ -250,4 +250,7 @@ stripLeading(str, 'abc');
 @category Type Guard
 @category Utilities
 */
-export type IsLiteral<T extends Primitive> = IsNotFalse<IsLiteralUnion<T>>;
+export type IsLiteral<T> =
+	IsPrimitive<T> extends true
+		? IsNotFalse<IsLiteralUnion<T>>
+		: false;

package/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