type-fest 2.13.0 → 2.15.0

package/index.d.ts

@@ -18,7 +18,7 @@ export {PartialDeep} from './source/partial-deep';
 export {ReadonlyDeep} from './source/readonly-deep';
 export {LiteralUnion} from './source/literal-union';
 export {Promisable} from './source/promisable';
-export {Opaque} from './source/opaque';
+export {Opaque, UnwrapOpaque} from './source/opaque';
 export {InvariantOf} from './source/invariant-of';
 export {SetOptional} from './source/set-optional';
 export {SetRequired} from './source/set-required';

package/package.json

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

package/readme.md

@@ -172,6 +172,7 @@ Click the type names for complete docs.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
 - [`Opaque`](source/opaque.d.ts) - Create an [opaque type](https://codemix.com/opaque-types-in-javascript/).
+- [`UnwrapOpaque`](source/opaque.d.ts) - Revert an [opaque type](https://codemix.com/opaque-types-in-javascript/) back to its original type.
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
 - [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional.
 - [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required.

package/source/jsonify.d.ts

@@ -1,14 +1,9 @@
 import type {JsonPrimitive, JsonValue} from './basic';
+import {Finite, NegativeInfinity, PositiveInfinity} from './numeric';
+import {TypedArray} from './typed-array';
 
 // Note: The return value has to be `any` and not `unknown` so it can match `void`.
-type NotJsonable = ((...args: any[]) => any) | undefined;
-
-// Note: Handles special case where Arrays with `undefined` are transformed to `'null'` by `JSON.stringify()`
-// Only use with array members
-type JsonifyArrayMember<T> =
-	T extends undefined ?
-		null | Exclude<T, undefined> :
-		Jsonify<T>;
+type NotJsonable = ((...args: any[]) => any) | undefined | symbol;
 
 /**
 Transform a type to one that is assignable to the `JsonValue` type.
@@ -71,16 +66,26 @@ type Jsonify<T> =
 	// Check if there are any non-JSONable types represented in the union.
 	// Note: The use of tuples in this first condition side-steps distributive conditional types
 	// (see https://github.com/microsoft/TypeScript/issues/29368#issuecomment-453529532)
-	[Extract<T, NotJsonable>] extends [never]
-		? T extends JsonPrimitive
+	[Extract<T, NotJsonable | BigInt>] extends [never]
+		? T extends PositiveInfinity | NegativeInfinity ? null
+		: T extends JsonPrimitive
 			? T // Primitive is acceptable
+			: T extends Number ? number
+			: T extends String ? string
+			: T extends Boolean ? boolean
+			: T extends Map<any, any> | Set<any> ? {}
+			: T extends TypedArray ? Record<string, number>
 			: T extends Array<infer U>
-				? Array<JsonifyArrayMember<U>> // It's an array: recursive call for its children
+				? Array<Jsonify<U extends NotJsonable ? null : U>> // It's an array: recursive call for its children
 				: T extends object
 					? T extends {toJSON(): infer J}
 						? (() => 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<Required<T>[P]>} // It's an object: recursive call for its children
+						: {[P in keyof T as P extends symbol
+							? never
+							: T[P] extends NotJsonable
+							? never
+							: P]: 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

package/source/numeric.d.ts

@@ -34,6 +34,8 @@ You can't pass a `bigint` as they are already guaranteed to be finite.
 
 Use-case: Validating and documenting parameters.
 
+Note: This can't detect `NaN`, please upvote [this issue](https://github.com/microsoft/TypeScript/issues/28682) if you want to have this type as a built-in in TypeScript.
+
 @example
 ```
 import type {Finite} from 'type-fest';

package/source/opaque.d.ts

@@ -72,3 +72,36 @@ type Person = {
 @category Type
 */
 export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
+
+/**
+Revert an opaque type back to its original type by removing the readonly `[tag]`.
+
+Why is this necessary?
+
+1. Use an `Opaque` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Opaque, UnwrapOpaque} from 'type-fest';
+
+type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1
+};
+
+// Without UnwrapOpaque, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
+type WontWork = UnwrapOpaque<string>;
+```
+
+@category Type
+*/
+export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> =
+	OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]>
+		? Type
+		: OpaqueType;

package/source/tsconfig-json.d.ts

@@ -713,7 +713,7 @@ declare namespace TsConfigJson {
 		/**
 		Specify path mapping to be computed relative to baseUrl option.
 		*/
-		paths?: Partial<Record<string, string[]>>;
+		paths?: Record<string, string[]>;
 
 		/**
 		List of TypeScript language server plugins to load.

package/license

@@ -1 +0,0 @@
-SPDX-License-Identifier: (MIT OR CC0-1.0)