@wo658/redpact 0.4.1 → 0.5.0

package/node_modules/type-fest/source/int-range.d.ts

@@ -0,0 +1,55 @@
+import type {BuildTuple} from './internal';
+import type {Subtract} from './subtract';
+
+/**
+Generate a union of numbers.
+
+The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
+
+You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
+
+Note: `Start` or `End` must be non-negative and smaller than `1000`.
+
+Use-cases:
+1. This can be used to define a set of valid input/output values. for example:
+	```
+	type Age = IntRange<0, 120>;
+	type FontSize = IntRange<10, 20>;
+	type EvenNumber = IntRange<0, 11, 2>; //=> 0 | 2 | 4 | 6 | 8 | 10
+	```
+2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
+
+@example
+```
+import type {IntRange} from 'type-fest';
+
+// Create union type `0 | 1 | ... | 9`
+type ZeroToNine = IntRange<0, 10>;
+
+// Create union type `100 | 200 | 300 | ... | 900`
+type Hundreds = IntRange<100, 901, 100>;
+```
+
+@see IntClosedRange
+*/
+export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+
+/**
+The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
+*/
+type PrivateIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	Gap extends number = Subtract<Step, 1>, // The gap between each number, gap = step - 1
+	List extends unknown[] = BuildTuple<Start, never>, // The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
+	EndLengthTuple extends unknown[] = BuildTuple<End>,
+> = Gap extends 0 ?
+	// Handle the case that without `Step`
+	List['length'] extends End // The result of "List[length] === End"
+		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
+	// Handle the case that with `Step`
+	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...BuildTuple<Gap, never>` maybe make `List` too long.
+		? Exclude<List[number], never>
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...BuildTuple<Gap, never>]>;

package/node_modules/type-fest/source/internal/array.d.ts

@@ -0,0 +1,126 @@
+import type {IfNever} from '../if-never';
+import type {UnknownArray} from '../unknown-array';
+
+/**
+Infer the length of the given array `<T>`.
+
+@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+*/
+type ArrayLength<T extends readonly unknown[]> = T extends {readonly length: infer L} ? L : never;
+
+/**
+Matches any unknown array or tuple.
+*/
+export type UnknownArrayOrTuple = readonly [...unknown[]];
+// TODO: should unknown-array be updated?
+
+/**
+Extracts the type of the first element of an array or tuple.
+*/
+export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]]
+	? THead
+	: never;
+
+/**
+Extract the element of an array that also works for array union.
+
+Returns `never` if T is not an array.
+
+It creates a type-safe way to access the element type of `unknown` type.
+*/
+export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+
+/**
+Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = StaticPartOfArray<A>;
+//=> [string, number, boolean]
+```
+*/
+export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
+	T extends unknown
+		? number extends T['length'] ?
+			T extends readonly [infer U, ...infer V]
+				? StaticPartOfArray<V, [...Result, U]>
+				: Result
+			: T
+		: never; // Should never happen
+
+/**
+Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = VariablePartOfArray<A>;
+//=> string[]
+```
+*/
+export type VariablePartOfArray<T extends UnknownArray> =
+	T extends unknown
+		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
+			? U
+			: []
+		: never; // Should never happen
+
+/**
+Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
+
+@example
+```
+type ReadonlyArray = readonly string[];
+type NormalArray = string[];
+
+type ReadonlyResult = SetArrayAccess<NormalArray, true>;
+//=> readonly string[]
+
+type NormalResult = SetArrayAccess<ReadonlyArray, false>;
+//=> string[]
+```
+*/
+export type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
+T extends readonly [...infer U] ?
+	IsReadonly extends true
+		? readonly [...U]
+		: [...U]
+	: T;
+
+/**
+Returns whether the given array `T` is readonly.
+*/
+export type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
+
+/**
+An if-else-like type that resolves depending on whether the given array is readonly.
+
+@see {@link IsArrayReadonly}
+
+@example
+```
+import type {ArrayTail} from 'type-fest';
+
+type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
+	ArrayTail<TArray> extends infer Tail
+		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
+		: never;
+
+type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
+//=> readonly [number, boolean]
+
+type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
+//=> [number, boolean]
+
+type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
+//=> true
+
+type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
+//=> 'bar'
+```
+*/
+export type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> =
+	IsArrayReadonly<T> extends infer Result
+		? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly
+		: never; // Should never happen

package/node_modules/type-fest/source/internal/characters.d.ts

@@ -0,0 +1,67 @@
+export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+
+export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
+export type Whitespace =
+	| '\u{9}' // '\t'
+	| '\u{A}' // '\n'
+	| '\u{B}' // '\v'
+	| '\u{C}' // '\f'
+	| '\u{D}' // '\r'
+	| '\u{20}' // ' '
+	| '\u{85}'
+	| '\u{A0}'
+	| '\u{1680}'
+	| '\u{2000}'
+	| '\u{2001}'
+	| '\u{2002}'
+	| '\u{2003}'
+	| '\u{2004}'
+	| '\u{2005}'
+	| '\u{2006}'
+	| '\u{2007}'
+	| '\u{2008}'
+	| '\u{2009}'
+	| '\u{200A}'
+	| '\u{2028}'
+	| '\u{2029}'
+	| '\u{202F}'
+	| '\u{205F}'
+	| '\u{3000}'
+	| '\u{FEFF}';
+
+export type WordSeparators = '-' | '_' | Whitespace;
+
+export type AsciiPunctuation =
+	| '!'
+	| '"'
+	| '#'
+	| '$'
+	| '%'
+	| '&'
+	| '\''
+	| '('
+	| ')'
+	| '*'
+	| '+'
+	| ','
+	| '-'
+	| '.'
+	| '/'
+	| ':'
+	| ';'
+	| '<'
+	| '='
+	| '>'
+	| '?'
+	| '@'
+	| '['
+	| '\\'
+	| ']'
+	| '^'
+	| '_'
+	| '`'
+	| '{'
+	| '|'
+	| '}'
+	| '~';

package/node_modules/type-fest/source/internal/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './array';
+export type * from './characters';
+export type * from './keys';
+export type * from './numeric';
+export type * from './object';
+export type * from './string';
+export type * from './tuple';
+export type * from './type';

package/node_modules/type-fest/source/internal/keys.d.ts

@@ -0,0 +1,97 @@
+import type {IsAny} from '../is-any';
+import type {IsLiteral} from '../is-literal';
+import type {ToString} from './string';
+
+// Returns `never` if the key or property is not jsonable without testing whether the property is required or optional otherwise return the key.
+type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
+	? never
+	: Type[Key] extends symbol
+		? never
+		/*
+		To prevent a problem where an object with only a `name` property is incorrectly treated as assignable to a function, we first check if the property is a record.
+		This check is necessary, because without it, if we don't verify whether the property is a record, an object with a type of `{name: any}` would return `never` due to its potential assignability to a function.
+		See: https://github.com/sindresorhus/type-fest/issues/657
+		*/
+		: Type[Key] extends Record<string, unknown>
+			? Key
+			: [(...arguments_: any[]) => any] extends [Type[Key]]
+				? never
+				: Key;
+
+/**
+Returns the required keys.
+*/
+export type FilterDefinedKeys<T extends object> = Exclude<
+{
+	[Key in keyof T]: IsAny<T[Key]> extends true
+		? Key
+		: undefined extends T[Key]
+			? never
+			: T[Key] extends undefined
+				? never
+				: BaseKeyFilter<T, Key>;
+}[keyof T],
+undefined
+>;
+
+/**
+Returns the optional keys.
+*/
+export type FilterOptionalKeys<T extends object> = Exclude<
+{
+	[Key in keyof T]: IsAny<T[Key]> extends true
+		? never
+		: undefined extends T[Key]
+			? T[Key] extends undefined
+				? never
+				: BaseKeyFilter<T, Key>
+			: never;
+}[keyof T],
+undefined
+>;
+
+/**
+Disallows any of the given keys.
+*/
+export type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+
+/**
+Utility type to retrieve only literal keys from type.
+*/
+export type LiteralKeyOf<T> = keyof {[K in keyof T as IsLiteral<K> extends true ? K : never]-?: never};
+
+/**
+Get the exact version of the given `Key` in the given object `T`.
+
+Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
+
+@example
+```
+type Object = {
+	0: number;
+	'1': string;
+};
+
+type Key1 = ExactKey<Object, '0'>;
+//=> 0
+type Key2 = ExactKey<Object, 0>;
+//=> 0
+
+type Key3 = ExactKey<Object, '1'>;
+//=> '1'
+type Key4 = ExactKey<Object, 1>;
+//=> '1'
+```
+
+@category Object
+*/
+export type ExactKey<T extends object, Key extends PropertyKey> =
+Key extends keyof T
+	? Key
+	: ToString<Key> extends keyof T
+		? ToString<Key>
+		: Key extends `${infer NumberKey extends number}`
+			? NumberKey extends keyof T
+				? NumberKey
+				: never
+			: never;

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

@@ -0,0 +1,118 @@
+import type {IsNever} from '../is-never';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric';
+import type {UnknownArray} from '../unknown-array';
+import type {StringToNumber} from './string';
+
+/**
+Returns the absolute value of a given value.
+
+@example
+```
+NumberAbsolute<-1>;
+//=> 1
+
+NumberAbsolute<1>;
+//=> 1
+
+NumberAbsolute<NegativeInfinity>
+//=> PositiveInfinity
+```
+*/
+export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+
+/**
+Check whether the given type is a number or a number string.
+
+Supports floating-point as a string.
+
+@example
+```
+type A = IsNumberLike<'1'>;
+//=> true
+
+type B = IsNumberLike<'-1.1'>;
+//=> true
+
+type C = IsNumberLike<1>;
+//=> true
+
+type D = IsNumberLike<'a'>;
+//=> false
+*/
+export type IsNumberLike<N> =
+	N extends number ? true
+		:	N extends `${number}`
+			? true
+			: N extends `${number}.${number}`
+				? true
+				: false;
+
+/**
+Returns the minimum number in the given union of numbers.
+
+Note: Just supports numbers from 0 to 999.
+
+@example
+```
+type A = UnionMin<3 | 1 | 2>;
+//=> 1
+```
+*/
+export type UnionMin<N extends number> = InternalUnionMin<N>;
+
+/**
+The actual implementation of `UnionMin`. It's private because it has some arguments that don't need to be exposed.
+*/
+type InternalUnionMin<N extends number, T extends UnknownArray = []> =
+	T['length'] extends N
+		? T['length']
+		: InternalUnionMin<N, [...T, unknown]>;
+
+/**
+Returns the maximum number in the given union of numbers.
+
+Note: Just supports numbers from 0 to 999.
+
+@example
+```
+type A = UnionMax<1 | 3 | 2>;
+//=> 3
+```
+*/
+export type UnionMax<N extends number> = InternalUnionMax<N>;
+
+/**
+The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
+*/
+type InternalUnionMax<N extends number, T extends UnknownArray = []> =
+	IsNever<N> extends true
+		? T['length']
+		:	T['length'] extends N
+			? InternalUnionMax<Exclude<N, T['length']>, T>
+			: InternalUnionMax<N, [...T, unknown]>;
+
+/**
+Returns the number with reversed sign.
+
+@example
+```
+ReverseSign<-1>;
+//=> 1
+
+ReverseSign<1>;
+//=> -1
+
+ReverseSign<NegativeInfinity>
+//=> PositiveInfinity
+
+ReverseSign<PositiveInfinity>
+//=> NegativeInfinity
+```
+*/
+export type ReverseSign<N extends number> =
+	// Handle edge cases
+	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
+	// Handle negative numbers
+	`${N}` extends `-${infer P extends number}` ? P
+		// Handle positive numbers
+		: `-${N}` extends `${infer R extends number}` ? R : never;