@wo658/redpact 0.3.0 → 0.5.0

package/node_modules/type-fest/source/multidimensional-readonly-array.d.ts

@@ -0,0 +1,48 @@
+import type {Subtract} from './subtract';
+import type {IsEqual} from './is-equal';
+
+type Recursive<T> = ReadonlyArray<Recursive<T>>;
+
+/**
+Creates a type that represents a multidimensional readonly array that of the given type and dimension.
+
+Use-cases:
+- Return a n-dimensional array from functions.
+- Declare a n-dimensional array by defining its dimensions rather than declaring `[]` repetitively.
+- Infer the dimensions of a n-dimensional array automatically from function arguments.
+- Avoid the need to know in advance the dimensions of a n-dimensional array allowing them to be dynamic.
+
+@example
+```
+import type {MultidimensionalReadonlyArray} from 'type-fest';
+
+function emptyMatrix<T extends number>(dimensions: T): MultidimensionalReadonlyArray<unknown, T> {
+	const matrix: unknown[] = [];
+
+	let subMatrix = matrix;
+	for (let dimension = 1; dimension < dimensions; ++dimension) {
+		console.log(`Initializing dimension #${dimension}`);
+
+		subMatrix[0] = [];
+		if (dimension < dimensions - 1) {
+			subMatrix = subMatrix[0] as unknown[];
+		} else {
+			subMatrix[0] = 42;
+		}
+	}
+
+	return matrix as MultidimensionalReadonlyArray<unknown, T>;
+}
+
+const matrix = emptyMatrix(3);
+
+const answer = matrix[0][0][0]; // 42
+```
+
+@category Array
+*/
+export type MultidimensionalReadonlyArray<Element, Dimensions extends number> = number extends Dimensions
+	? Recursive<Element>
+	: IsEqual<Dimensions, 0> extends true
+		? Element
+		: ReadonlyArray<MultidimensionalReadonlyArray<Element, Subtract<Dimensions, 1>>>;

package/node_modules/type-fest/source/non-empty-object.d.ts

@@ -0,0 +1,35 @@
+import type {HasRequiredKeys} from './has-required-keys';
+import type {RequireAtLeastOne} from './require-at-least-one';
+
+/**
+Represents an object with at least 1 non-optional key.
+
+This is useful when you need an object where all keys are optional, but there must be at least 1 key.
+
+@example
+```
+import type {NonEmptyObject} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+	id: number;
+};
+
+type UpdateRequest<Entity extends object> = NonEmptyObject<Partial<Entity>>;
+
+const update1: UpdateRequest<User> = {
+	name: 'Alice',
+	surname: 'Acme',
+};
+
+// At least 1 key is required, therefore this will report a 2322 error:
+// Type '{}' is not assignable to type 'UpdateRequest<User>'
+const update2: UpdateRequest<User> = {};
+```
+
+@see Use `IsEmptyObject` to check whether an object is empty.
+
+@category Object
+*/
+export type NonEmptyObject<T extends object> = HasRequiredKeys<T> extends true ? T : RequireAtLeastOne<T, keyof T>;

package/node_modules/type-fest/source/non-empty-string.d.ts

@@ -0,0 +1,28 @@
+/**
+Matches any non-empty string.
+
+This is useful when you need a string that is not empty, for example, as a function parameter.
+
+NOTE:
+- This returns `never` not just when instantiated with an empty string, but also when an empty string is a subtype of the instantiated type, like `string` or `Uppercase<string>`.
+
+@example
+```
+import type {NonEmptyString} from 'type-fest';
+
+declare function foo<T extends string>(string: NonEmptyString<T>): void;
+
+foo('a');
+//=> OK
+
+foo('');
+//=> Error: Argument of type '""' is not assignable to parameter of type 'never'.
+
+declare const someString: string
+foo(someString);
+//=> Error: Argument of type 'string' is not assignable to parameter of type 'never'.
+```
+
+@category String
+*/
+export type NonEmptyString<T extends string> = '' extends T ? never : T;

package/node_modules/type-fest/source/non-empty-tuple.d.ts

@@ -0,0 +1,21 @@
+/**
+Matches any non-empty tuple.
+
+@example
+```
+import type {NonEmptyTuple} from 'type-fest';
+
+const sum = (...numbers: NonEmptyTuple<number>) => numbers.reduce((total, value) => total + value, 0);
+
+sum(1, 2, 3);
+//=> 6
+
+sum();
+//=> Error: Expected at least 1 arguments, but got 0.
+```
+
+@see {@link RequireAtLeastOne} for objects
+
+@category Array
+*/
+export type NonEmptyTuple<T = unknown> = readonly [T, ...T[]];

package/node_modules/type-fest/source/numeric.d.ts

@@ -0,0 +1,222 @@
+import type {IsFloat} from './is-float';
+import type {IsInteger} from './is-integer';
+
+export type Numeric = number | bigint;
+
+export type Zero = 0 | 0n;
+
+/**
+Matches the hidden `Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see NegativeInfinity
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+export type PositiveInfinity = 1e999;
+
+/**
+Matches the hidden `-Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see PositiveInfinity
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+export type NegativeInfinity = -1e999;
+
+/**
+A finite `number`.
+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';
+
+declare function setScore<T extends number>(length: Finite<T>): void;
+```
+
+@category Numeric
+*/
+export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfinity ? never : T;
+
+/**
+A `number` that is an integer.
+
+Use-case: Validating and documenting parameters.
+
+@example
+```
+type Integer = Integer<1>;
+//=> 1
+
+type IntegerWithDecimal = Integer<1.0>;
+//=> 1
+
+type NegativeInteger = Integer<-1>;
+//=> -1
+
+type Float = Integer<1.5>;
+//=> never
+
+// Supports non-decimal numbers
+
+type OctalInteger: Integer<0o10>;
+//=> 0o10
+
+type BinaryInteger: Integer<0b10>;
+//=> 0b10
+
+type HexadecimalInteger: Integer<0x10>;
+//=> 0x10
+```
+
+@example
+```
+import type {Integer} from 'type-fest';
+
+declare function setYear<T extends number>(length: Integer<T>): void;
+```
+
+@see NegativeInteger
+@see NonNegativeInteger
+
+@category Numeric
+*/
+// `${bigint}` is a type that matches a valid bigint literal without the `n` (ex. 1, 0b1, 0o1, 0x1)
+// Because T is a number and not a string we can effectively use this to filter out any numbers containing decimal points
+export type Integer<T> =
+	T extends unknown // To distributive type
+		? IsInteger<T> extends true ? T : never
+		: never; // Never happens
+
+/**
+A `number` that is not an integer.
+
+Use-case: Validating and documenting parameters.
+
+It does not accept `Infinity`.
+
+@example
+```
+import type {Float} from 'type-fest';
+
+declare function setPercentage<T extends number>(length: Float<T>): void;
+```
+
+@see Integer
+
+@category Numeric
+*/
+export type Float<T> =
+T extends unknown // To distributive type
+	? IsFloat<T> extends true ? T : never
+	: never; // Never happens
+
+/**
+A negative (`-∞ < x < 0`) `number` that is not an integer.
+Equivalent to `Negative<Float<T>>`.
+
+Use-case: Validating and documenting parameters.
+
+@see Negative
+@see Float
+
+@category Numeric
+*/
+export type NegativeFloat<T extends number> = Negative<Float<T>>;
+
+/**
+A negative `number`/`bigint` (`-∞ < x < 0`)
+
+Use-case: Validating and documenting parameters.
+
+@see NegativeInteger
+@see NonNegative
+
+@category Numeric
+*/
+export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+
+/**
+A negative (`-∞ < x < 0`) `number` that is an integer.
+Equivalent to `Negative<Integer<T>>`.
+
+You can't pass a `bigint` as they are already guaranteed to be integers, instead use `Negative<T>`.
+
+Use-case: Validating and documenting parameters.
+
+@see Negative
+@see Integer
+
+@category Numeric
+*/
+export type NegativeInteger<T extends number> = Negative<Integer<T>>;
+
+/**
+A non-negative `number`/`bigint` (`0 <= x < ∞`).
+
+Use-case: Validating and documenting parameters.
+
+@see NonNegativeInteger
+@see Negative
+
+@example
+```
+import type {NonNegative} from 'type-fest';
+
+declare function setLength<T extends number>(length: NonNegative<T>): void;
+```
+
+@category Numeric
+*/
+export type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : never;
+
+/**
+A non-negative (`0 <= x < ∞`) `number` that is an integer.
+Equivalent to `NonNegative<Integer<T>>`.
+
+You can't pass a `bigint` as they are already guaranteed to be integers, instead use `NonNegative<T>`.
+
+Use-case: Validating and documenting parameters.
+
+@see NonNegative
+@see Integer
+
+@example
+```
+import type {NonNegativeInteger} from 'type-fest';
+
+declare function setLength<T extends number>(length: NonNegativeInteger<T>): void;
+```
+
+@category Numeric
+*/
+export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
+
+/**
+Returns a boolean for whether the given number is a negative number.
+
+@see Negative
+
+@example
+```
+import type {IsNegative} from 'type-fest';
+
+type ShouldBeFalse = IsNegative<1>;
+type ShouldBeTrue = IsNegative<-1>;
+```
+
+@category Numeric
+*/
+export type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;

package/node_modules/type-fest/source/observable-like.d.ts

@@ -0,0 +1,63 @@
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+export type Unsubscribable = {
+	unsubscribe(): void;
+};
+
+/**
+@category Observable
+*/
+type OnNext<ValueType> = (value: ValueType) => void;
+/**
+@category Observable
+*/
+type OnError = (error: unknown) => void;
+/**
+@category Observable
+*/
+type OnComplete = () => void;
+
+/**
+@category Observable
+*/
+export type Observer<ValueType> = {
+	next: OnNext<ValueType>;
+	error: OnError;
+	complete: OnComplete;
+};
+
+/**
+Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+
+@remarks
+The TC39 Observable proposal defines 2 forms of `subscribe()`:
+1. Three callback arguments: `subscribe(observer: OnNext<ValueType>, onError?: OnError, onComplete?: OnComplete): Unsubscribable;`
+2. A single `observer` argument: (as defined below)
+
+But `Observable` implementations have evolved to preferring case 2 and some implementations choose not to implement case 1. Therefore, an `ObservableLike` cannot be trusted to implement the first case. (xstream and hand built observerables often do not implement case 1)
+
+@see https://github.com/tc39/proposal-observable#observable
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L246-L259
+@see https://benlesh.com/posts/learning-observable-by-building-observable/
+
+@category Observable
+*/
+export type ObservableLike<ValueType = unknown> = {
+	subscribe(observer?: Partial<Observer<ValueType>>): Unsubscribable;
+	[Symbol.observable](): ObservableLike<ValueType>;
+};

package/node_modules/type-fest/source/omit-deep.d.ts

@@ -0,0 +1,167 @@
+import type {ArraySplice} from './array-splice';
+import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToString} from './internal';
+import type {IsEqual} from './is-equal';
+import type {IsNever} from './is-never';
+import type {LiteralUnion} from './literal-union';
+import type {Paths} from './paths';
+import type {SimplifyDeep} from './simplify-deep';
+import type {UnionToTuple} from './union-to-tuple';
+import type {UnknownArray} from './unknown-array';
+
+/**
+Omit properties from a deeply-nested object.
+
+It supports recursing into arrays.
+
+It supports removing specific items from an array, replacing each removed item with unknown at the specified index.
+
+Use-case: Remove unneeded parts of complex objects.
+
+Use [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
+
+@example
+```
+import type {OmitDeep} from 'type-fest';
+
+type Info = {
+	userInfo: {
+		name: string;
+		uselessInfo: {
+			foo: string;
+		};
+	};
+};
+
+type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
+// type UsefulInfo = {
+// 	userInfo: {
+// 		name: string;
+// 	};
+// };
+
+// Supports removing multiple paths
+type Info1 = {
+	userInfo: {
+		name: string;
+		uselessField: string;
+		uselessInfo: {
+			foo: string;
+		};
+	};
+};
+
+type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
+// type UsefulInfo1 = {
+// 	userInfo: {
+// 		name: string;
+// 	};
+// };
+
+// Supports array
+type A = OmitDeep<[1, 'foo', 2], 1>;
+// type A = [1, unknown, 2];
+
+// Supports recursing into array
+
+type Info1 = {
+	address: [
+		{
+			street: string
+		},
+		{
+			street2: string,
+			foo: string
+		};
+	];
+}
+type AddressInfo = OmitDeep<Info1, 'address.1.foo'>;
+// type AddressInfo = {
+// 	address: [
+// 		{
+// 			street: string;
+// 		},
+// 		{
+// 			street2: string;
+// 		};
+// 	];
+// };
+```
+
+@category Object
+@category Array
+*/
+export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
+	SimplifyDeep<
+	OmitDeepHelper<T, UnionToTuple<PathUnion>>,
+	UnknownArray>;
+
+/**
+Internal helper for {@link OmitDeep}.
+
+Recursively transforms `T` by applying {@link OmitDeepWithOnePath} for each path in `PathTuple`.
+*/
+type OmitDeepHelper<T, PathTuple extends UnknownArray> =
+	PathTuple extends [infer Path, ...infer RestPaths]
+		? OmitDeepHelper<OmitDeepWithOnePath<T, Path & (string | number)>, RestPaths>
+		: T;
+
+/**
+Omit one path from the given object/array.
+*/
+type OmitDeepWithOnePath<T, Path extends string | number> =
+T extends NonRecursiveType
+	? T
+	: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
+		: T extends object ? OmitDeepObjectWithOnePath<T, Path>
+			: T;
+
+/**
+Omit one path from the given object.
+*/
+type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> =
+P extends `${infer RecordKeyInPath}.${infer SubPath}`
+	? {
+		[Key in keyof ObjectT]:
+		IsEqual<RecordKeyInPath, ToString<Key>> extends true
+			? ExactKey<ObjectT, Key> extends infer RealKey
+				? RealKey extends keyof ObjectT
+					? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
+					: ObjectT[Key]
+				: ObjectT[Key]
+			: ObjectT[Key]
+	}
+	: ExactKey<ObjectT, P> extends infer Key
+		? IsNever<Key> extends true
+			? ObjectT
+			: Key extends PropertyKey
+				? Omit<ObjectT, Key>
+				: ObjectT
+		: ObjectT;
+
+/**
+Omit one path from from the given array.
+
+It replaces the item to `unknown` at the given index.
+
+@example
+```
+type A = OmitDeepArrayWithOnePath<[10, 20, 30, 40], 2>;
+//=> type A = [10, 20, unknown, 40];
+```
+*/
+type OmitDeepArrayWithOnePath<ArrayType extends UnknownArray, P extends string | number> =
+	// Handle paths that are `${number}.${string}`
+	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
+		// If `ArrayIndex` is equal to `number`
+		? number extends ArrayIndex
+			? Array<OmitDeepWithOnePath<NonNullable<ArrayType[number]>, SubPath>>
+			// If `ArrayIndex` is a number literal
+			: ArraySplice<ArrayType, ArrayIndex, 1, [OmitDeepWithOnePath<NonNullable<ArrayType[ArrayIndex]>, SubPath>]>
+		// If the path is equal to `number`
+		: P extends `${infer ArrayIndex extends number}`
+			// If `ArrayIndex` is `number`
+			? number extends ArrayIndex
+				? []
+				// If `ArrayIndex` is a number literal
+				: ArraySplice<ArrayType, ArrayIndex, 1, [unknown]>
+			: ArrayType;

package/node_modules/type-fest/source/omit-index-signature.d.ts

@@ -0,0 +1,95 @@
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+export type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};

package/node_modules/type-fest/source/opaque.d.ts

@@ -0,0 +1 @@
+export * from './tagged';