type-fest 3.5.7 → 3.6.0

package/index.d.ts

@@ -8,6 +8,7 @@ export * from './source/observable-like';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {Except} from './source/except';
 export type {Writable} from './source/writable';
+export type {WritableDeep} from './source/writable-deep';
 export type {Merge} from './source/merge';
 export type {MergeDeep, MergeDeepOptions} from './source/merge-deep';
 export type {MergeExclusive} from './source/merge-exclusive';

package/package.json

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

package/readme.md

@@ -129,6 +129,7 @@ Click the type names for complete docs.
 - [`IsEmptyObject`](source/empty-object.d.ts) - Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
 - [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly<T>`.
+- [`WritableDeep`](source/writable-deep.d.ts) - Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
 - [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type.
 - [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.

package/source/internal.d.ts

@@ -242,3 +242,18 @@ type FilterOptionalKeys<T extends object> = Exclude<
 }[keyof T],
 undefined
 >;
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+export type HasMultipleCallSignatures<T extends (...arguments: any[]) => unknown> =
+	T extends {(...arguments: infer A): unknown; (...arguments: any[]): unknown}
+		? unknown[] extends A
+			? false
+			: true
+		: false;

package/source/package-json.d.ts

@@ -224,7 +224,10 @@ declare namespace PackageJson {
 	string
 	>;
 
-	type ExportConditions = {[condition in ExportCondition]: Exports};
+	/**
+	A mapping of conditions and the paths to which they resolve.
+	*/
+	type ExportConditions = {[condition in ExportCondition]?: Exports};
 
 	/**
 	Entry points of a module, optionally with conditions and subpath exports.
@@ -233,14 +236,13 @@ declare namespace PackageJson {
 	| null
 	| string
 	| Array<string | ExportConditions>
-	| ExportConditions
-	| {[path: string]: Exports};
+	| ExportConditions;
 
 	/**
-	Import map entries of a module, optionally with conditions.
+	Import map entries of a module, optionally with conditions and subpath imports.
 	*/
 	export type Imports = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
-		[key: `#${string}`]: string | {[key in ExportCondition]?: Exports};
+		[key: `#${string}`]: Exports;
 	};
 
 	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions

package/source/readonly-deep.d.ts

@@ -1,4 +1,4 @@
-import type {BuiltIns} from './internal';
+import type {BuiltIns, HasMultipleCallSignatures} from './internal';
 
 /**
 Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
@@ -29,6 +29,8 @@ data.foo.push('bar');
 //=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
 ```
 
+Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
 @category Object
 @category Array
 @category Set
@@ -66,18 +68,3 @@ Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper fo
 type ReadonlyObjectDeep<ObjectType extends object> = {
 	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
 };
-
-/**
-Test if the given function has multiple call signatures.
-
-Needed to handle the case of a single call signature with properties.
-
-Multiple call signatures cannot currently be supported due to a TypeScript limitation.
-@see https://github.com/microsoft/TypeScript/issues/29732
-*/
-type HasMultipleCallSignatures<T extends (...arguments: any[]) => unknown> =
-	T extends {(...arguments: infer A): unknown; (...arguments: any[]): unknown}
-		? unknown[] extends A
-			? false
-			: true
-		: false;

package/source/writable-deep.d.ts

@@ -0,0 +1,64 @@
+import type {BuiltIns, HasMultipleCallSignatures} from './internal';
+import type {Writable} from './writable.js';
+
+/**
+Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
+
+@example
+```
+import type {WritableDeep} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: readonly string[]; // To show that mutability is deeply affected.
+	readonly c: boolean;
+};
+
+const writableDeepFoo: WritableDeep<Foo> = {a: 1, b: ['2'], c: true};
+writableDeepFoo.a = 3;
+writableDeepFoo.b[0] = 'new value';
+writableDeepFoo.b = ['something'];
+```
+
+Note that types containing overloaded functions are not made deeply writable due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@see Writable
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type WritableDeep<T> = T extends BuiltIns
+	? T
+	: T extends (...arguments: any[]) => unknown
+		? {} extends WritableObjectDeep<T>
+			? T
+			: HasMultipleCallSignatures<T> extends true
+				? T
+				: ((...arguments: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
+		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
+			? WritableMapDeep<KeyType, ValueType>
+			: T extends Readonly<ReadonlySet<infer ItemType>>
+				? WritableSetDeep<ItemType>
+				: T extends object
+					? WritableObjectDeep<T>
+					: unknown;
+
+/**
+Same as `WritableDeep`, but accepts only `Map`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableMapDeep<KeyType, ValueType> = {} & Writable<Map<WritableDeep<KeyType>, WritableDeep<ValueType>>>;
+
+/**
+Same as `WritableDeep`, but accepts only `Set`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableSetDeep<ItemType> = {} & Writable<Set<WritableDeep<ItemType>>>;
+
+/**
+Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableObjectDeep<ObjectType extends object> = {
+	-readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>
+};