type-fest 1.2.3 → 2.1.0

package/index.d.ts

@@ -1,2 +1,63 @@
-// These are all the basic types that's compatible with all supported TypeScript versions.
-export * from './base';
+// Basic
+export * from './source/primitive';
+export * from './source/typed-array';
+export * from './source/basic';
+export * from './source/observable-like';
+
+// Utilities
+export {Except} from './source/except';
+export {Mutable} from './source/mutable';
+export {Merge} from './source/merge';
+export {MergeExclusive} from './source/merge-exclusive';
+export {RequireAtLeastOne} from './source/require-at-least-one';
+export {RequireExactlyOne} from './source/require-exactly-one';
+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 {SetOptional} from './source/set-optional';
+export {SetRequired} from './source/set-required';
+export {ValueOf} from './source/value-of';
+export {PromiseValue} from './source/promise-value';
+export {AsyncReturnType} from './source/async-return-type';
+export {ConditionalExcept} from './source/conditional-except';
+export {ConditionalKeys} from './source/conditional-keys';
+export {ConditionalPick} from './source/conditional-pick';
+export {UnionToIntersection} from './source/union-to-intersection';
+export {Stringified} from './source/stringified';
+export {FixedLengthArray} from './source/fixed-length-array';
+export {IterableElement} from './source/iterable-element';
+export {Entry} from './source/entry';
+export {Entries} from './source/entries';
+export {SetReturnType} from './source/set-return-type';
+export {Asyncify} from './source/asyncify';
+export {Simplify} from './source/simplify';
+export {Jsonify} from './source/jsonify';
+
+// Template literal types
+export {CamelCase} from './source/camel-case';
+export {CamelCasedProperties} from './source/camel-cased-properties';
+export {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep';
+export {KebabCase} from './source/kebab-case';
+export {KebabCasedProperties} from './source/kebab-cased-properties';
+export {KebabCasedPropertiesDeep} from './source/kebab-cased-properties-deep';
+export {PascalCase} from './source/pascal-case';
+export {PascalCasedProperties} from './source/pascal-cased-properties';
+export {PascalCasedPropertiesDeep} from './source/pascal-cased-properties-deep';
+export {SnakeCase} from './source/snake-case';
+export {SnakeCasedProperties} from './source/snake-cased-properties';
+export {SnakeCasedPropertiesDeep} from './source/snake-cased-properties-deep';
+export {ScreamingSnakeCase} from './source/screaming-snake-case';
+export {DelimiterCase} from './source/delimiter-case';
+export {DelimiterCasedProperties} from './source/delimiter-cased-properties';
+export {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep';
+export {Split} from './source/split';
+export {Trim} from './source/trim';
+export {Includes} from './source/includes';
+export {Get} from './source/get';
+export {LastArrayElement} from './source/last-array-element';
+
+// Miscellaneous
+export {PackageJson} from './source/package-json';
+export {TsConfigJson} from './source/tsconfig-json';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "1.2.3",
+	"version": "2.1.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -11,16 +11,14 @@
 		"url": "https://sindresorhus.com"
 	},
 	"engines": {
-		"node": ">=10"
+		"node": ">=12.20"
 	},
 	"scripts": {
 		"test": "xo && tsd && tsc"
 	},
 	"files": [
 		"index.d.ts",
-		"base.d.ts",
-		"source",
-		"ts41"
+		"source"
 	],
 	"keywords": [
 		"typescript",
@@ -35,24 +33,20 @@
 	],
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
-		"expect-type": "^0.11.0",
-		"tsd": "^0.14.0",
+		"expect-type": "^0.12.0",
+		"tsd": "^0.17.0",
 		"typescript": "^4.1.3",
-		"xo": "^0.36.1"
+		"xo": "^0.43.0"
 	},
 	"types": "./index.d.ts",
-	"typesVersions": {
-		">=4.1": {
-			"*": [
-				"ts41/*"
-			]
-		}
-	},
 	"xo": {
 		"rules": {
 			"@typescript-eslint/ban-types": "off",
 			"@typescript-eslint/indent": "off",
-			"node/no-unsupported-features/es-builtins": "off"
+			"node/no-unsupported-features/es-builtins": "off",
+			"import/extensions": "off",
+			"@typescript-eslint/no-redeclare": "off",
+			"@typescript-eslint/no-confusing-void-expression": "off"
 		}
 	}
 }

package/readme.md

@@ -60,7 +60,7 @@ PR welcome for additional commonly needed types and docs improvements. Read the
 $ npm install type-fest
 ```
 
-*Requires TypeScript >=3.4*
+*Requires TypeScript >=4.2*
 
 ## Usage
 
@@ -83,8 +83,10 @@ Click the type names for complete docs.
 ### Basic
 
 - [`Primitive`](source/primitive.d.ts) - Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-- [`Class`](source/basic.d.ts) - Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+- [`Class`](source/basic.d.ts) - Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+- [`Constructor`](source/basic.d.ts) - Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 - [`TypedArray`](source/typed-array.d.ts) - Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+- [`JsonPrimitive`](source/basic.d.ts) - Matches a JSON primitive.
 - [`JsonObject`](source/basic.d.ts) - Matches a JSON object.
 - [`JsonArray`](source/basic.d.ts) - Matches a JSON array.
 - [`JsonValue`](source/basic.d.ts) - Matches any valid JSON value.
@@ -119,36 +121,37 @@ Click the type names for complete docs.
 - [`Entries`](source/entries.d.ts) - Create a type that represents the type of the entries of a collection.
 - [`SetReturnType`](source/set-return-type.d.ts) - Create a function type with a return type of your choice and the same parameters as the given function type.
 - [`Asyncify`](source/asyncify.d.ts) - Create an async version of the given function type.
+- [`Includes`](source/includes.d.ts) - Returns a boolean for whether the given array includes the given item.
+- [`Simplify`](source/simplify.d.ts) - Flatten the type output to improve type hints shown in editors.
+- [`Jsonify`](source/jsonify.d.ts) - Transform a type to one that is assignable to the `JsonValue` type.
 
 ### Template literal types
 
-*Note:* These require [TypeScript 4.1 or newer](https://devblogs.microsoft.com/typescript/announcing-typescript-4-1/#template-literal-types).
-
-- [`CamelCase`](ts41/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
-- [`CamelCasedProperties`](ts41/camel-cased-properties.d.ts) – Convert object properties to camel-case  (`fooBar`).
-- [`CamelCasedPropertiesDeep`](ts41/camel-cased-properties-deep.d.ts) – Convert object properties to camel-case recursively  (`fooBar`).
-- [`KebabCase`](ts41/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
-- [`KebabCasedProperties`](ts41/kebab-cased-properties.d.ts) – Convert a object properties to kebab-case recursively (`foo-bar`).
-- [`KebabCasedPropertiesDeep`](ts41/kebab-cased-properties-deep.d.ts) – Convert object properties to kebab-case (`foo-bar`).
-- [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
-- [`PascalCasedProperties`](ts41/pascal-cased-properties.d.ts) – Converts object properties to pascal-case (`FooBar`)
-- [`PascalCasedPropertiesDeep`](ts41/pascal-cased-properties-deep.d.ts) – Converts object properties to pascal-case (`FooBar`)
-- [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
-- [`SnakeCasedProperties`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case (`foo_bar`).
-- [`SnakeCasedPropertiesDeep`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case recursively (`foo_bar`).
-- [`ScreamingSnakeCase`](ts41/screaming-snake-case.d.ts) - Convert a string literal to screaming-snake-case (`FOO_BAR`).
-- [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
-- [`DelimiterCasedProperties`](ts41/delimiter-cased-properties.d.ts) – Convert object properties to a custom string delimiter casing.
-- [`DelimiterCasedPropertiesDeep`](ts41/delimiter-cased-properties-deep.d.ts) – Convert object properties to a custom string delimiter casing recursively.
-- [`Split`](ts41/split.d.ts) - Represents an array of strings split using a given character or character set.
-- [`Trim`](ts41/trim.d.ts) - Remove leading and trailing spaces from a string.
-- [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
-- [`LastArrayElement`](ts41/last-array-element.d.ts) - Extracts the type of the last element of an array.
+- [`CamelCase`](source/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
+- [`CamelCasedProperties`](source/camel-cased-properties.d.ts) – Convert object properties to camel-case  (`fooBar`).
+- [`CamelCasedPropertiesDeep`](source/camel-cased-properties-deep.d.ts) – Convert object properties to camel-case recursively  (`fooBar`).
+- [`KebabCase`](source/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
+- [`KebabCasedProperties`](source/kebab-cased-properties.d.ts) – Convert a object properties to kebab-case recursively (`foo-bar`).
+- [`KebabCasedPropertiesDeep`](source/kebab-cased-properties-deep.d.ts) – Convert object properties to kebab-case (`foo-bar`).
+- [`PascalCase`](source/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
+- [`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`).
+- [`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.
+- [`DelimiterCasedProperties`](source/delimiter-cased-properties.d.ts) – Convert object properties to a custom string delimiter casing.
+- [`DelimiterCasedPropertiesDeep`](source/delimiter-cased-properties-deep.d.ts) – Convert object properties to a custom string delimiter casing recursively.
+- [`Split`](source/split.d.ts) - Represents an array of strings split using a given character or character set.
+- [`Trim`](source/trim.d.ts) - Remove leading and trailing spaces from a string.
+- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
+- [`LastArrayElement`](source/last-array-element.d.ts) - Extracts the type of the last element of an array.
 
 ### Miscellaneous
 
 - [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file).
-- [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 3.7).
+- [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 4.4).
 
 ## Declined types
 

package/source/basic.d.ts

@@ -1,10 +1,16 @@
-// TODO: Remove the `= unknown` sometime  in the future when most users are on TS 3.5 as it's now the default
+/**
+Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Basic
+*/
+export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {prototype: T};
+
 /**
 Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
 @category Basic
 */
-export type Class<T = unknown, Arguments extends any[] = any[]> = new(...arguments_: Arguments) => T;
+export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
 
 /**
 Matches a JSON object.
@@ -20,13 +26,20 @@ Matches a JSON array.
 
 @category Basic
 */
-export interface JsonArray extends Array<JsonValue> {}
-// TODO: Make it this when targeting TypeScript 4.1:
-// export type JsonArray = JsonValue[];
+export type JsonArray = JsonValue[];
+
+/**
+Matches any valid JSON primitive value.
+
+@category Basic
+*/
+export type JsonPrimitive = string | number | boolean | null;
 
 /**
 Matches any valid JSON value.
 
+@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
+
 @category Basic
 */
-export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

package/{ts41 → source}/camel-case.d.ts

@@ -1,5 +1,5 @@
 import {WordSeparators} from '../source/utilities';
-import {Split} from './utilities';
+import {Split} from './split';
 
 /**
 Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
@@ -8,7 +8,7 @@ Only to be used by `CamelCaseStringArray<>`.
 
 @see CamelCaseStringArray
 */
-type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> =
+type InnerCamelCaseStringArray<Parts extends readonly any[], PreviousPart> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
 		? FirstPart extends undefined
 			? ''
@@ -24,7 +24,7 @@ It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to
 
 @see Split
 */
-type CamelCaseStringArray<Parts extends string[]> =
+type CamelCaseStringArray<Parts extends readonly string[]> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
 		? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`>
 		: never;

package/{ts41 → source}/delimiter-case.d.ts

@@ -36,7 +36,7 @@ It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensur
 
 @see SplitIncludingDelimiters
 */
-type StringArrayToDelimiterCase<Parts extends any[], UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+type StringArrayToDelimiterCase<Parts extends readonly any[], UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
 		? `${StringPartToDelimiterCase<FirstPart, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
 		: '';

package/{ts41 → source}/delimiter-cased-properties-deep.d.ts

@@ -42,7 +42,7 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 */
 export type DelimiterCasedPropertiesDeep<
 	Value,
-	Delimiter extends string
+	Delimiter extends string,
 > = Value extends Function
 	? Value
 	: Value extends Array<infer U>

package/{ts41 → source}/delimiter-cased-properties.d.ts

@@ -25,9 +25,9 @@ const result: DelimiterCasedProperties<User, '-'> = {
 */
 export type DelimiterCasedProperties<
 	Value,
-	Delimiter extends string
+	Delimiter extends string,
 > = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 	? Value
-	: { [K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K] };
+	: {[K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K]};

package/source/entries.d.ts

@@ -54,6 +54,6 @@ const setEntries: Entries<typeof setExample> = [['a', 'a'], [1, 1]];
 export type Entries<BaseType> =
 	BaseType extends Map<unknown, unknown> ? MapEntries<BaseType>
 		: BaseType extends Set<unknown> ? SetEntries<BaseType>
-		: BaseType extends unknown[] ? ArrayEntries<BaseType>
+		: BaseType extends readonly unknown[] ? ArrayEntries<BaseType>
 		: BaseType extends object ? ObjectEntries<BaseType>
 		: never;

package/source/entry.d.ts

@@ -57,6 +57,6 @@ const setEntryNumber: Entry<typeof setExample> = [1, 1];
 export type Entry<BaseType> =
 	BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
 		: BaseType extends Set<unknown> ? SetEntry<BaseType>
-		: BaseType extends unknown[] ? ArrayEntry<BaseType>
+		: BaseType extends readonly unknown[] ? ArrayEntry<BaseType>
 		: BaseType extends object ? ObjectEntry<BaseType>
 		: never;

package/{ts41 → source}/get.d.ts

@@ -1,5 +1,5 @@
-import {Split} from './utilities';
 import {StringDigit} from '../source/utilities';
+import {Split} from './split';
 
 /**
 Like the `Get` type but receives an array of strings as a path parameter.
@@ -81,6 +81,8 @@ type PropertyOf<BaseType, Key extends string> =
 	? undefined
 	: Key extends keyof BaseType
 	? BaseType[Key]
+	: BaseType extends [] | [unknown, ...unknown[]]
+	? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds.
 	: BaseType extends {
 		[n: number]: infer Item;
 		length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.

package/source/includes.d.ts

@@ -0,0 +1,31 @@
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+*/
+type IsEqual<T, U> =
+	(<G>() => G extends T ? 1 : 2) extends
+	(<G>() => G extends U ? 1 : 2)
+		? true
+		: false;
+
+/**
+Returns a boolean for whether the given array includes the given item.
+
+This can be useful if another type wants to make a decision based on whether the array includes that item.
+
+@example
+```
+import {Includes} from 'type-fest';
+
+type hasRed<array extends any[]> = Includes<array, 'red'>;
+```
+
+@category Utilities
+*/
+export type Includes<Value extends readonly any[], Item> =
+	IsEqual<Value[0], Item> extends true
+		? true
+		: Value extends [Value[0], ...infer rest]
+			? Includes<rest, Item>
+			: false;

package/source/jsonify.d.ts

@@ -0,0 +1,55 @@
+import {JsonPrimitive} from './basic';
+
+// Note: The return value has to be `any` and not `unknown` so it can match `void`.
+type NotJsonable = ((...args: any[]) => any) | undefined;
+
+/**
+Transform a type to one that is assignable to the `JsonValue` type.
+
+@remarks
+
+An interface cannot be structurally compared to `JsonValue` because an interface can be re-opened to add properties that may not be satisfy `JsonValue`.
+
+@example
+```
+interface Geometry {
+	type: 'Point' | 'Polygon';
+	coordinates: [number, number];
+}
+
+const point: Geometry = {
+	type: 'Point',
+	coordinates: [1, 1]
+};
+
+const problemFn = (data: JsonValue) => {
+	// Does something with data
+};
+
+problemFn(point); // Error: type Geometry is not assignable to parameter of type JsonValue because it is an interface
+
+const fixedFn = <T>(data: Jsonify<T>) => {
+	// Does something with data
+};
+
+fixedFn(point); // Good: point is assignable. Jsonify<T> transforms Geometry into value assignable to JsonValue
+fixedFn(new Date()); // Error: As expected, Date is not assignable. Jsonify<T> cannot transforms Date into value assignable to JsonValue
+```
+
+@link https://github.com/Microsoft/TypeScript/issues/1897#issuecomment-710744173
+
+@category Utilities
+*/
+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
+			? T // Primitive is acceptable
+			: T extends Array<infer U>
+				? Array<Jsonify<U>> // It's an array: recursive call for its children
+				: T extends object
+					? {[P in keyof T]: Jsonify<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/{ts41 → source}/last-array-element.d.ts

@@ -7,7 +7,7 @@ Use-case: Defining the return type of functions that extract the last element of
 ```
 import {LastArrayElement} from 'type-fest';
 
-declare function lastOf<V extends any[]>(array: V): LastArrayElement<V>;
+declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
 
 const array = ['foo', 2];
 
@@ -17,7 +17,7 @@ typeof lastOf(array);
 
 @category Template Literals
 */
-export type LastArrayElement<ValueType extends unknown[]> =
+export type LastArrayElement<ValueType extends readonly unknown[]> =
 	ValueType extends [infer ElementType]
 		? ElementType
 		: ValueType extends [infer _, ...infer Tail]

package/source/literal-union.d.ts

@@ -31,5 +31,5 @@ const pet: Pet2 = '';
  */
 export type LiteralUnion<
 	LiteralType,
-	BaseType extends Primitive
+	BaseType extends Primitive,
 > = LiteralType | (BaseType & {_?: never});

package/source/observable-like.d.ts

@@ -9,7 +9,7 @@ Matches a value that is like an [Observable](https://github.com/tc39/proposal-ob
 
 @category Basic
 */
-export interface ObservableLike {
-	subscribe(observer: (value: unknown) => void): void;
-	[Symbol.observable](): ObservableLike;
+export interface ObservableLike<ValueType = unknown> {
+	subscribe(observer: (value: ValueType) => void): void;
+	[Symbol.observable](): ObservableLike<ValueType>;
 }

package/source/opaque.d.ts

@@ -1,3 +1,9 @@
+declare const tag: unique symbol;
+
+declare type Tagged<Token> = {
+	readonly [tag]: Token;
+};
+
 /**
 Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
 
@@ -6,6 +12,7 @@ The generic type parameter can be anything. It doesn't have to be an object.
 [Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
 
 There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
 	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
 	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
 
@@ -16,7 +23,7 @@ import {Opaque} from 'type-fest';
 type AccountNumber = Opaque<number, 'AccountNumber'>;
 type AccountBalance = Opaque<number, 'AccountBalance'>;
 
-// The Token parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
 type ThingOne = Opaque<string>;
 type ThingTwo = Opaque<string>;
 
@@ -64,4 +71,4 @@ type Person = {
 
 @category Utilities
 */
-export type Opaque<Type, Token = unknown> = Type & {readonly __opaque__: Token};
+export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;

package/source/package-json.d.ts

@@ -269,6 +269,11 @@ declare namespace PackageJson {
 		*/
 		types?: string;
 
+		/**
+		Version selection map of TypeScript.
+		*/
+		typesVersions?: Record<string, Record<string, string[]>>;
+
 		/**
 		Location of the bundled TypeScript declaration file. Alias of `types`.
 		*/

package/{ts41 → source}/pascal-cased-properties.d.ts

@@ -27,4 +27,4 @@ export type PascalCasedProperties<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 	? Value
-	: { [K in keyof Value as PascalCase<K>]: Value[K] };
+	: {[K in keyof Value as PascalCase<K>]: Value[K]};

package/source/promise-value.d.ts

@@ -25,5 +25,5 @@ let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promi
 @category Utilities
 */
 export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value>
-	? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
+	? {0: PromiseValue<Value>; 1: Value}[PromiseType extends Promise<unknown> ? 0 : 1]
 	: Otherwise;

package/source/require-at-least-one.d.ts

@@ -24,7 +24,7 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 */
 export type RequireAtLeastOne<
 	ObjectType,
-	KeysType extends keyof ObjectType = keyof ObjectType
+	KeysType extends keyof ObjectType = keyof ObjectType,
 > = {
 	// For each `Key` in `KeysType` make a mapped type:
 	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required

package/source/require-exactly-one.d.ts

@@ -1,6 +1,3 @@
-// TODO: Remove this when we target TypeScript >=3.5.
-type _Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
-
 /**
 Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
 
@@ -34,4 +31,4 @@ export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = ke
 	{[Key in KeysType]: (
 		Required<Pick<ObjectType, Key>> &
 		Partial<Record<Exclude<KeysType, Key>, never>>
-	)}[KeysType] & _Omit<ObjectType, KeysType>;
+	)}[KeysType] & Omit<ObjectType, KeysType>;

package/{ts41 → source}/screaming-snake-case.d.ts

@@ -1,14 +1,6 @@
 import {SplitIncludingDelimiters} from './delimiter-case';
 import {SnakeCase} from './snake-case';
-
-/**
-Returns a boolean for whether the given array includes the given item.
-*/
-type Includes<Value extends any[], Item> = {
-	[P in keyof Value & number as Value[P]]: true;
-}[Item] extends true
-	? true
-	: false;
+import {Includes} from './includes';
 
 /**
 Returns a boolean for whether the string is screaming snake case.

package/source/simplify.d.ts

@@ -1,4 +1,24 @@
 /**
 Flatten the type output to improve type hints shown in editors.
+
+@example
+```
+import {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+@category Utilities
 */
 export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

package/{ts41 → source}/split.d.ts

@@ -20,7 +20,7 @@ array = split(items, ',');
 */
 export type Split<
 	S extends string,
-	Delimiter extends string
+	Delimiter extends string,
 > = S extends `${infer Head}${Delimiter}${infer Tail}`
 	? [Head, ...Split<Tail, Delimiter>]
 	: S extends Delimiter

package/source/tsconfig-json.d.ts

@@ -3,6 +3,8 @@ declare namespace TsConfigJson {
 		export type JSX =
 			| 'preserve'
 			| 'react'
+			| 'react-jsx'
+			| 'react-jsxdev'
 			| 'react-native';
 
 		export type Module =
@@ -12,6 +14,7 @@ declare namespace TsConfigJson {
 			| 'UMD'
 			| 'ES6'
 			| 'ES2015'
+			| 'ES2020'
 			| 'ESNext'
 			| 'None'
 			// Lowercase alternatives
@@ -21,6 +24,7 @@ declare namespace TsConfigJson {
 			| 'umd'
 			| 'es6'
 			| 'es2015'
+			| 'es2020'
 			| 'esnext'
 			| 'none';
 
@@ -41,6 +45,7 @@ declare namespace TsConfigJson {
 			| 'ES2018'
 			| 'ES2019'
 			| 'ES2020'
+			| 'ES2021'
 			| 'ESNext'
 			// Lowercase alternatives
 			| 'es3'
@@ -52,6 +57,7 @@ declare namespace TsConfigJson {
 			| 'es2018'
 			| 'es2019'
 			| 'es2020'
+			| 'es2021'
 			| 'esnext';
 
 		export type Lib =
@@ -77,6 +83,7 @@ declare namespace TsConfigJson {
 			| 'ES2017.String'
 			| 'ES2017.TypedArrays'
 			| 'ES2018'
+			| 'ES2018.AsyncGenerator'
 			| 'ES2018.AsyncIterable'
 			| 'ES2018.Intl'
 			| 'ES2018.Promise'
@@ -87,19 +94,31 @@ declare namespace TsConfigJson {
 			| 'ES2019.String'
 			| 'ES2019.Symbol'
 			| 'ES2020'
+			| 'ES2020.BigInt'
+			| 'ES2020.Promise'
 			| 'ES2020.String'
 			| 'ES2020.Symbol.WellKnown'
+			| 'ES2020.SharedMemory'
+			| 'ES2020.Intl'
+			| 'ES2021'
+			| 'ES2021.Promise'
+			| 'ES2021.String'
+			| 'ES2021.WeakRef'
 			| 'ESNext'
 			| 'ESNext.Array'
 			| 'ESNext.AsyncIterable'
 			| 'ESNext.BigInt'
 			| 'ESNext.Intl'
+			| 'ESNext.Promise'
+			| 'ESNext.String'
 			| 'ESNext.Symbol'
+			| 'ESNext.WeakRef'
 			| 'DOM'
 			| 'DOM.Iterable'
 			| 'ScriptHost'
 			| 'WebWorker'
 			| 'WebWorker.ImportScripts'
+			| 'WebWorker.Iterable'
 			// Lowercase alternatives
 			| 'es5'
 			| 'es6'
@@ -123,6 +142,7 @@ declare namespace TsConfigJson {
 			| 'es2017.string'
 			| 'es2017.typedarrays'
 			| 'es2018'
+			| 'es2018.asyncgenerator'
 			| 'es2018.asynciterable'
 			| 'es2018.intl'
 			| 'es2018.promise'
@@ -133,19 +153,31 @@ declare namespace TsConfigJson {
 			| 'es2019.string'
 			| 'es2019.symbol'
 			| 'es2020'
+			| 'es2020.bigint'
+			| 'es2020.promise'
 			| 'es2020.string'
 			| 'es2020.symbol.wellknown'
+			| 'es2020.sharedmemory'
+			| 'es2020.intl'
+			| 'es2021'
+			| 'es2021.promise'
+			| 'es2021.string'
+			| 'es2021.weakref'
 			| 'esnext'
 			| 'esnext.array'
 			| 'esnext.asynciterable'
 			| 'esnext.bigint'
 			| 'esnext.intl'
+			| 'esnext.promise'
+			| 'esnext.string'
 			| 'esnext.symbol'
+			| 'esnext.weakref'
 			| 'dom'
 			| 'dom.iterable'
 			| 'scripthost'
 			| 'webworker'
-			| 'webworker.importscripts';
+			| 'webworker.importscripts'
+			| 'webworker.iterable';
 
 		export interface Plugin {
 			[key: string]: unknown;
@@ -154,6 +186,35 @@ declare namespace TsConfigJson {
 			*/
 			name?: string;
 		}
+
+		export type ImportsNotUsedAsValues =
+			| 'remove'
+			| 'preserve'
+			| 'error';
+
+		export type FallbackPolling =
+			| 'fixedPollingInterval'
+			| 'priorityPollingInterval'
+			| 'dynamicPriorityPolling'
+			| 'fixedInterval'
+			| 'priorityInterval'
+			| 'dynamicPriority'
+			| 'fixedChunkSize';
+
+		export type WatchDirectory =
+			| 'useFsEvents'
+			| 'fixedPollingInterval'
+			| 'dynamicPriorityPolling'
+			| 'fixedChunkSizePolling';
+
+		export type WatchFile =
+			| 'fixedPollingInterval'
+			| 'priorityPollingInterval'
+			| 'dynamicPriorityPolling'
+			| 'useFsEvents'
+			| 'useFsEventsOnParentDirectory'
+			| 'fixedChunkSizePolling';
+
 	}
 
 	export interface CompilerOptions {
@@ -192,6 +253,24 @@ declare namespace TsConfigJson {
 		*/
 		diagnostics?: boolean;
 
+		/**
+		Reduce the number of projects loaded automatically by TypeScript.
+
+		Requires TypeScript version 4.0 or later.
+
+		@default false
+		*/
+		disableReferencedProjectLoad?: boolean;
+
+		/**
+		Enforces using indexed accessors for keys declared using an indexed type.
+
+		Requires TypeScript version 4.2 or later.
+
+		@default false
+		*/
+		noPropertyAccessFromIndexSignature?: boolean;
+
 		/**
 		Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.
 
@@ -206,6 +285,15 @@ declare namespace TsConfigJson {
 		*/
 		emitDeclarationOnly?: boolean;
 
+		/**
+		Differentiate between undefined and not present when type checking.
+
+		Requires TypeScript version 4.4 or later.
+
+		@default false
+		*/
+		exactOptionalPropertyTypes?: boolean;
+
 		/**
 		Enable incremental compilation.
 
@@ -237,7 +325,7 @@ declare namespace TsConfigJson {
 		inlineSources?: boolean;
 
 		/**
-		Specify JSX code generation: `'preserve'`, `'react'`, or `'react-native'`.
+		Specify what JSX code is generated.
 
 		@default 'preserve'
 		*/
@@ -250,6 +338,33 @@ declare namespace TsConfigJson {
 		*/
 		reactNamespace?: string;
 
+		/**
+		Specify the JSX factory function to use when targeting React JSX emit, e.g. `React.createElement` or `h`.
+
+		Requires TypeScript version 2.1 or later.
+
+		@default 'React.createElement'
+		*/
+		jsxFactory?: string;
+
+		/**
+		Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'.
+
+		Requires TypeScript version 4.0 or later.
+
+		@default 'React.Fragment'
+		*/
+		jsxFragmentFactory?: string;
+
+		/**
+		Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.
+
+		Requires TypeScript version 4.1 or later.
+
+		@default 'react'
+		*/
+		jsxImportSource?: string;
+
 		/**
 		Print names of files part of the compilation.
 
@@ -269,6 +384,13 @@ declare namespace TsConfigJson {
 		*/
 		module?: CompilerOptions.Module;
 
+		/**
+		Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6).
+
+		@default ['AMD', 'System', 'ES6'].includes(module) ? 'classic' : 'node'
+		*/
+		moduleResolution?: 'classic' | 'node';
+
 		/**
 		Specifies the end of line sequence to be used when emitting files: 'crlf' (Windows) or 'lf' (Unix).
 
@@ -461,6 +583,15 @@ declare namespace TsConfigJson {
 		*/
 		target?: CompilerOptions.Target;
 
+		/**
+		Default catch clause variables as `unknown` instead of `any`.
+
+		Requires TypeScript version 4.4 or later.
+
+		@default false
+		*/
+		useUnknownInCatchVariables?: boolean;
+
 		/**
 		Watch input files.
 
@@ -468,6 +599,31 @@ declare namespace TsConfigJson {
 		*/
 		watch?: boolean;
 
+		/**
+		Specify the polling strategy to use when the system runs out of or doesn't support native file watchers.
+
+		Requires TypeScript version 3.8 or later.
+		*/
+		fallbackPolling?: CompilerOptions.FallbackPolling;
+
+		/**
+		Specify the strategy for watching directories under systems that lack recursive file-watching functionality.
+
+		Requires TypeScript version 3.8 or later.
+
+		@default 'useFsEvents'
+		*/
+		watchDirectory?: CompilerOptions.WatchDirectory;
+
+		/**
+		Specify the strategy for watching individual files.
+
+		Requires TypeScript version 3.8 or later.
+
+		@default 'useFsEvents'
+		*/
+		watchFile?: CompilerOptions.WatchFile;
+
 		/**
 		Enables experimental support for ES7 decorators.
 
@@ -482,13 +638,6 @@ declare namespace TsConfigJson {
 		*/
 		emitDecoratorMetadata?: boolean;
 
-		/**
-		Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6).
-
-		@default ['AMD', 'System', 'ES6'].includes(module) ? 'classic' : 'node'
-		*/
-		moduleResolution?: 'classic' | 'node';
-
 		/**
 		Do not report errors on unused labels.
 
@@ -503,6 +652,15 @@ declare namespace TsConfigJson {
 		*/
 		noImplicitReturns?: boolean;
 
+		/**
+		Add `undefined` to a type when accessed using an index.
+
+		Requires TypeScript version 4.1 or later.
+
+		@default false
+		*/
+		noUncheckedIndexedAccess?: boolean;
+
 		/**
 		Report errors for fallthrough cases in switch statement.
 
@@ -510,6 +668,13 @@ declare namespace TsConfigJson {
 		*/
 		noFallthroughCasesInSwitch?: boolean;
 
+		/**
+		Ensure overriding members in derived classes are marked with an override modifier.
+
+		@default false
+		*/
+		noImplicitOverride?: boolean;
+
 		/**
 		Do not report errors on unreachable code.
 
@@ -524,6 +689,15 @@ declare namespace TsConfigJson {
 		*/
 		forceConsistentCasingInFileNames?: boolean;
 
+		/**
+		Emit a v8 CPU profile of the compiler run for debugging.
+
+		Requires TypeScript version 3.7 or later.
+
+		@default 'profile.cpuprofile'
+		*/
+		generateCpuProfile?: string;
+
 		/**
 		Base directory to resolve non-relative module names.
 		*/
@@ -646,13 +820,11 @@ declare namespace TsConfigJson {
 		importHelpers?: boolean;
 
 		/**
-		Specify the JSX factory function to use when targeting React JSX emit, e.g. `React.createElement` or `h`.
+		Specify emit/checking behavior for imports that are only used for types.
 
-		Requires TypeScript version 2.1 or later.
-
-		@default 'React.createElement'
+		@default 'remove'
 		*/
-		jsxFactory?: string;
+		importsNotUsedAsValues?: CompilerOptions.ImportsNotUsedAsValues;
 
 		/**
 		Parse in strict mode and emit `'use strict'` for each source file.
@@ -766,6 +938,54 @@ declare namespace TsConfigJson {
 		@default false
 		*/
 		resolveJsonModule?: boolean;
+
+		/**
+		Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it.
+
+		Requires TypeScript version 3.8 or later.
+
+		@default false
+		*/
+		assumeChangesOnlyAffectDirectDependencies?: boolean;
+
+		/**
+		Output more detailed compiler performance information after building.
+
+		@default false
+		*/
+		extendedDiagnostics?: boolean;
+
+		/**
+		Print names of files that are part of the compilation and then stop processing.
+
+		@default false
+		*/
+		listFilesOnly?: boolean;
+
+		/**
+		Disable preferring source files instead of declaration files when referencing composite projects.
+
+		@default true if composite, false otherwise
+		*/
+		disableSourceOfProjectReferenceRedirect?: boolean;
+
+		/**
+		Opt a project out of multi-project reference checking when editing.
+
+		Requires TypeScript version 3.8 or later.
+
+		@default false
+		*/
+		disableSolutionSearching?: boolean;
+
+		/**
+		Print names of files which TypeScript sees as a part of your project and the reason they are part of the compilation.
+
+		Requires TypeScript version 4.2 or later.
+
+		@default false
+		*/
+		explainFiles?: boolean;
 	}
 
 	/**

package/source/typed-array.d.ts

@@ -1,5 +1,3 @@
-/// <reference lib="es2020.bigint"/>
-
 /**
 Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
 

package/base.d.ts

@@ -1,41 +0,0 @@
-// Types that are compatible with all supported TypeScript versions.
-// It's shared between all TypeScript version-specific definitions.
-
-// Basic
-export * from './source/primitive';
-export * from './source/typed-array';
-export * from './source/basic';
-export * from './source/observable-like';
-
-// Utilities
-export {Except} from './source/except';
-export {Mutable} from './source/mutable';
-export {Merge} from './source/merge';
-export {MergeExclusive} from './source/merge-exclusive';
-export {RequireAtLeastOne} from './source/require-at-least-one';
-export {RequireExactlyOne} from './source/require-exactly-one';
-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 {SetOptional} from './source/set-optional';
-export {SetRequired} from './source/set-required';
-export {ValueOf} from './source/value-of';
-export {PromiseValue} from './source/promise-value';
-export {AsyncReturnType} from './source/async-return-type';
-export {ConditionalExcept} from './source/conditional-except';
-export {ConditionalKeys} from './source/conditional-keys';
-export {ConditionalPick} from './source/conditional-pick';
-export {UnionToIntersection} from './source/union-to-intersection';
-export {Stringified} from './source/stringified';
-export {FixedLengthArray} from './source/fixed-length-array';
-export {IterableElement} from './source/iterable-element';
-export {Entry} from './source/entry';
-export {Entries} from './source/entries';
-export {SetReturnType} from './source/set-return-type';
-export {Asyncify} from './source/asyncify';
-
-// Miscellaneous
-export {PackageJson} from './source/package-json';
-export {TsConfigJson} from './source/tsconfig-json';

package/ts41/index.d.ts

@@ -1,24 +0,0 @@
-// These are all the basic types that's compatible with all supported TypeScript versions.
-export * from '../base';
-
-// These are special types that require at least TypeScript 4.1.
-export {CamelCase} from './camel-case';
-export {CamelCasedProperties} from './camel-cased-properties';
-export {CamelCasedPropertiesDeep} from './camel-cased-properties-deep';
-export {KebabCase} from './kebab-case';
-export {KebabCasedProperties} from './kebab-cased-properties';
-export {KebabCasedPropertiesDeep} from './kebab-cased-properties-deep';
-export {PascalCase} from './pascal-case';
-export {PascalCasedProperties} from './pascal-cased-properties';
-export {PascalCasedPropertiesDeep} from './pascal-cased-properties-deep';
-export {SnakeCase} from './snake-case';
-export {SnakeCasedProperties} from './snake-cased-properties';
-export {SnakeCasedPropertiesDeep} from './snake-cased-properties-deep';
-export {ScreamingSnakeCase} from './screaming-snake-case';
-export {DelimiterCase} from './delimiter-case';
-export {DelimiterCasedProperties} from './delimiter-cased-properties';
-export {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
-export {Split} from './split';
-export {Trim} from './trim';
-export {Get} from './get';
-export {LastArrayElement} from './last-array-element';

package/ts41/utilities.d.ts

@@ -1,8 +0,0 @@
-/**
-Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
-*/
-export type Split<S extends string, D extends string> =
-	string extends S ? string[] :
-	S extends '' ? [] :
-	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
-	[S];