type-fest 3.10.0 → 3.11.0

package/index.d.ts

@@ -25,6 +25,7 @@ export type {
 } from './source/omit-index-signature';
 export type {PickIndexSignature} from './source/pick-index-signature';
 export type {PartialDeep, PartialDeepOptions} from './source/partial-deep';
+export type {RequiredDeep} from './source/required-deep';
 export type {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
 export type {ReadonlyDeep} from './source/readonly-deep';
 export type {LiteralUnion} from './source/literal-union';
@@ -76,6 +77,8 @@ export type {OverrideProperties} from './source/override-properties';
 export type {HasOptionalKeys} from './source/has-optional-keys';
 export type {RequiredKeysOf} from './source/required-keys-of';
 export type {HasRequiredKeys} from './source/has-required-keys';
+export type {ReadonlyKeysOf} from './source/readonly-keys-of';
+export type {WritableKeysOf} from './source/writable-keys-of';
 export type {Spread} from './source/spread';
 export type {TupleToUnion} from './source/tuple-to-union';
 export type {IsEqual} from './source/is-equal';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "3.10.0",
+	"version": "3.11.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -36,12 +36,9 @@
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
 		"expect-type": "^0.15.0",
-		"tsd": "^0.28.0",
-		"typescript": "^5.0.2",
-		"xo": "^0.53.1"
-	},
-	"peerDependencies": {
-		"typescript": ">=4.7.0"
+		"tsd": "^0.28.1",
+		"typescript": "^5.0.4",
+		"xo": "^0.54.2"
 	},
 	"xo": {
 		"rules": {
@@ -50,7 +47,8 @@
 			"@typescript-eslint/naming-convention": "off",
 			"import/extensions": "off",
 			"@typescript-eslint/no-redeclare": "off",
-			"@typescript-eslint/no-confusing-void-expression": "off"
+			"@typescript-eslint/no-confusing-void-expression": "off",
+			"@typescript-eslint/no-unsafe-argument": "off"
 		}
 	},
 	"tsd": {

package/readme.md

@@ -108,6 +108,7 @@ Click the type names for complete docs.
 - [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys.
+- [`RequiredDeep`](source/required-deep.d.ts) - Create a deeply required version of another type. Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
 - [`OmitIndexSignature`](source/omit-index-signature.d.ts) - Omit any index signatures from the given object type, leaving only explicitly defined properties.
 - [`PickIndexSignature`](source/pick-index-signature.d.ts) - Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 - [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
@@ -142,6 +143,8 @@ Click the type names for complete docs.
 - [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields.
 - [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type.
 - [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields.
+- [`ReadonlyKeysOf`](source/readonly-keys-of.d.ts) - Extract all writable (non-readonly) keys from the given type.
+- [`WritableKeysOf`](source/writable-keys-of.d.ts) - Extract all readonly keys from the given type.
 - [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
 - [`IsEqual`](source/is-equal.d.ts) - Returns a boolean for whether the two given types are equal.
 - [`TaggedUnion`](source/tagged-union.d.ts) - Create a union of types that share a common discriminant property.
@@ -239,7 +242,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`PascalCasedProperties`](source/pascal-cased-properties.d.ts) - Converts object properties to pascal-case (`FooBar`)
 - [`PascalCasedPropertiesDeep`](source/pascal-cased-properties-deep.d.ts) - Converts object properties to pascal-case (`FooBar`)
 - [`SnakeCase`](source/snake-case.d.ts) - Convert a string literal to snake-case (`foo_bar`).
-- [`SnakeCasedProperties`](source/snake-cased-properties-deep.d.ts) - Convert object properties to snake-case (`foo_bar`).
+- [`SnakeCasedProperties`](source/snake-cased-properties.d.ts) - Convert object properties to snake-case (`foo_bar`).
 - [`SnakeCasedPropertiesDeep`](source/snake-cased-properties-deep.d.ts) - Convert object properties to snake-case recursively (`foo_bar`).
 - [`ScreamingSnakeCase`](source/screaming-snake-case.d.ts) - Convert a string literal to screaming-snake-case (`FOO_BAR`).
 - [`DelimiterCase`](source/delimiter-case.d.ts) - Convert a string literal to a custom string delimiter casing.

package/source/readonly-keys-of.d.ts

@@ -0,0 +1,29 @@
+import type {IsEqual} from './is-equal';
+
+/**
+Extract all readonly keys from the given type.
+
+This is useful when you want to create a new type that contains readonly keys only.
+
+@example
+```
+import type {ReadonlyKeysOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+	readonly id: number;
+}
+
+type UpdateResponse<Entity extends object> = Pick<Entity, ReadonlyKeysOf<Entity>>;
+
+const update1: UpdateResponse<User> = {
+    id: 123,
+};
+```
+
+@category Utilities
+*/
+export type ReadonlyKeysOf<T> = NonNullable<{
+	[P in keyof T]: IsEqual<{[Q in P]: T[P]}, {readonly [Q in P]: T[P]}> extends true ? P : never
+}[keyof T]>;

package/source/required-deep.d.ts

@@ -0,0 +1,78 @@
+import type {BuiltIns, HasMultipleCallSignatures} from './internal';
+
+type ExcludeUndefined<T> = Exclude<T, undefined>;
+
+/**
+Create a type from another type with all keys and nested keys set to required.
+
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
+
+@example
+```
+import type {RequiredDeep} from 'type-fest';
+
+type Settings = {
+	textEditor?: {
+		fontSize?: number | undefined;
+		fontColor?: string | undefined;
+		fontWeight?: number | undefined;
+	}
+	autocomplete?: boolean | undefined;
+	autosave?: boolean | undefined;
+};
+
+type RequiredSettings = RequiredDeep<Settings>;
+// type RequiredSettings = {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number;
+// 	}
+// 	autocomplete: boolean;
+// 	autosave: boolean;
+// }
+```
+
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Utilities
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns
+	? E
+	: E extends Map<infer KeyType, infer ValueType>
+		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+		: E extends Set<infer ItemType>
+			? Set<RequiredDeep<ItemType>>
+			: E extends ReadonlyMap<infer KeyType, infer ValueType>
+				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+				: E extends ReadonlySet<infer ItemType>
+					? ReadonlySet<RequiredDeep<ItemType>>
+					: E extends WeakMap<infer KeyType, infer ValueType>
+						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+						: E extends WeakSet<infer ItemType>
+							? WeakSet<RequiredDeep<ItemType>>
+							: E extends Promise<infer ValueType>
+								? Promise<RequiredDeep<ValueType>>
+								: E extends (...args: any[]) => unknown
+									? {} extends RequiredObjectDeep<E>
+										? E
+										: HasMultipleCallSignatures<E> extends true
+											? E
+											: ((...arguments: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
+									: E extends object
+										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+											? ItemType[] extends E // Test for arrays (non-tuples) specifically
+												? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
+												: RequiredObjectDeep<E> // Tuples behave properly
+											: RequiredObjectDeep<E>
+										: unknown;
+
+type RequiredObjectDeep<ObjectType extends object> = {
+	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
+};

package/source/writable-keys-of.d.ts

@@ -0,0 +1,30 @@
+import type {IsEqual} from './is-equal';
+
+/**
+Extract all writable keys from the given type.
+
+This is useful when you want to create a new type that contains writable keys only.
+
+@example
+```
+import type {WritableKeysOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+	readonly id: number;
+}
+
+type UpdateRequest<Entity extends object> = Pick<Entity, WritableKeysOf<Entity>>;
+
+const update1: UpdateRequest<User> = {
+	name: 'Alice',
+	surname: 'Acme',
+};
+```
+
+@category Utilities
+*/
+export type WritableKeysOf<T> = NonNullable<{
+	[P in keyof T]: IsEqual<{[Q in P]: T[P]}, {readonly [Q in P]: T[P]}> extends false ? P : never
+}[keyof T]>;