create-docusaurus 0.0.0-4483 → 0.0.0-4487

package/templates/facebook/node_modules/type-fest/source/promise-value.d.ts

@@ -1,27 +0,0 @@
-/**
-Returns the type that is wrapped inside a `Promise` type.
-If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
-If the type is not a `Promise`, the type itself is returned.
-
-@example
-```
-import {PromiseValue} from 'type-fest';
-
-type AsyncData = Promise<string>;
-let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
-
-type Data = PromiseValue<AsyncData>;
-let data: Data = await asyncData;
-
-// Here's an example that shows how this type reacts to non-Promise types.
-type SyncData = PromiseValue<string>;
-let syncData: SyncData = getSyncData();
-
-// Here's an example that shows how this type reacts to recursive Promise types.
-type RecursiveAsyncData = Promise<Promise<string> >;
-let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
-```
-*/
-export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value>
-	? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
-	: Otherwise;

package/templates/facebook/node_modules/type-fest/source/readonly-deep.d.ts

@@ -1,59 +0,0 @@
-import {Primitive} from './basic';
-
-/**
-Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
-
-This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-	"foo": ["bar"]
-}
-
-// main.ts
-import {ReadonlyDeep} from 'type-fest';
-import dataJson = require('./data.json');
-
-const data: ReadonlyDeep<typeof dataJson> = dataJson;
-
-export default data;
-
-// test.ts
-import data from './main';
-
-data.foo.push('bar');
-//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
-```
-*/
-export type ReadonlyDeep<T> = T extends Primitive | ((...arguments: any[]) => unknown)
-	? T
-	: T extends ReadonlyMap<infer KeyType, infer ValueType>
-	? ReadonlyMapDeep<KeyType, ValueType>
-	: T extends ReadonlySet<infer ItemType>
-	? ReadonlySetDeep<ItemType>
-	: T extends object
-	? ReadonlyObjectDeep<T>
-	: unknown;
-
-/**
-Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-interface ReadonlyMapDeep<KeyType, ValueType>
-	extends ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>> {}
-
-/**
-Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-interface ReadonlySetDeep<ItemType>
-	extends ReadonlySet<ReadonlyDeep<ItemType>> {}
-
-/**
-Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-type ReadonlyObjectDeep<ObjectType extends object> = {
-	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
-};

package/templates/facebook/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -1,32 +0,0 @@
-import {Except} from './except';
-
-/**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
-
-@example
-```
-import {RequireAtLeastOne} from 'type-fest';
-
-type Responder = {
-	text?: () => string;
-	json?: () => string;
-
-	secure?: boolean;
-};
-
-const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-*/
-export type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	{
-		// For each Key in KeysType make a mapped type
-		[Key in KeysType]: (
-			// …by picking that Key's type and making it required
-			Required<Pick<ObjectType, Key>>
-		)
-	}[KeysType]
-	// …then, make intersection types by adding the remaining keys to each mapped type.
-	& Except<ObjectType, KeysType>;

package/templates/facebook/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -1,35 +0,0 @@
-// 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.
-
-Use-cases:
-- Creating interfaces for components that only need one of the keys to display properly.
-- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
-
-The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
-
-@example
-```
-import {RequireExactlyOne} from 'type-fest';
-
-type Responder = {
-	text: () => string;
-	json: () => string;
-	secure: boolean;
-};
-
-const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
-	// Adding a `text` key here would cause a compile error.
-
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-*/
-export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	{[Key in KeysType]: (
-		Required<Pick<ObjectType, Key>> &
-		Partial<Record<Exclude<KeysType, Key>, never>>
-	)}[KeysType] & _Omit<ObjectType, KeysType>;

package/templates/facebook/node_modules/type-fest/source/set-optional.d.ts

@@ -1,34 +0,0 @@
-import {Except} from './except';
-
-/**
-Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
-
-@example
-```
-import {SetOptional} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b?: string;
-	c: boolean;
-}
-
-type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
-```
-*/
-export type SetOptional<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	// Pick just the keys that are not optional from the base type.
-	Except<BaseType, Keys> &
-	// Pick the keys that should be optional from the base type and make them optional.
-	Partial<Pick<BaseType, Keys>> extends
-	// If `InferredType` extends the previous, then for each key, use the inferred type key.
-	infer InferredType
-		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
-		: never;

package/templates/facebook/node_modules/type-fest/source/set-required.d.ts

@@ -1,34 +0,0 @@
-import {Except} from './except';
-
-/**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import {SetRequired} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b: string;
-	c?: boolean;
-}
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-```
-*/
-export type SetRequired<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	// Pick just the keys that are not required from the base type.
-	Except<BaseType, Keys> &
-	// Pick the keys that should be required from the base type and make them required.
-	Required<Pick<BaseType, Keys>> extends
-	// If `InferredType` extends the previous, then for each key, use the inferred type key.
-	infer InferredType
-		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
-		: never;

package/templates/facebook/node_modules/type-fest/source/set-return-type.d.ts

@@ -1,29 +0,0 @@
-type IsAny<T> = 0 extends (1 & T) ? true : false; // https://stackoverflow.com/a/49928360/3406963
-type IsNever<T> = [T] extends [never] ? true : false;
-type IsUnknown<T> = IsNever<T> extends false ? T extends unknown ? unknown extends T ? IsAny<T> extends false ? true : false : false : false : false;
-
-/**
-Create a function type with a return type of your choice and the same parameters as the given function type.
-
-Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
-
-@example
-```
-import {SetReturnType} from 'type-fest';
-
-type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
-
-type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
-//=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
-```
-*/
-export type SetReturnType<Fn extends (...args: any[]) => any, TypeToReturn> =
-	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
-	Fn extends (this: infer ThisArg, ...args: infer Arguments) => any ? (
-		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
-		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
-		IsUnknown<ThisArg> extends true ? (...args: Arguments) => TypeToReturn : (this: ThisArg, ...args: Arguments) => TypeToReturn
-	) : (
-		// This part should be unreachable, but we make it meaningful just in case…
-		(...args: Parameters<Fn>) => TypeToReturn
-	);

package/templates/facebook/node_modules/type-fest/source/stringified.d.ts

@@ -1,21 +0,0 @@
-/**
-Create a type with the keys of the given type changed to `string` type.
-
-Use-case: Changing interface values to strings in order to use them in a form model.
-
-@example
-```
-import {Stringified} from 'type-fest';
-
-type Car {
-	model: string;
-	speed: number;
-}
-
-const carForm: Stringified<Car> = {
-	model: 'Foo',
-	speed: '101'
-};
-```
-*/
-export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};