@wo658/redpact 0.3.0 → 0.5.0

package/node_modules/type-fest/source/is-unknown.d.ts

@@ -0,0 +1,52 @@
+import type {IsNull} from './is-null';
+
+/**
+Returns a boolean for whether the given type is `unknown`.
+
+@link https://github.com/dsherret/conditional-type-checks/pull/16
+
+Useful in type utilities, such as when dealing with unknown data from API calls.
+
+@example
+```
+import type {IsUnknown} from 'type-fest';
+
+// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts
+type Action<TState, TPayload = void> =
+	IsUnknown<TPayload> extends true
+		? (state: TState) => TState,
+		: (state: TState, payload: TPayload) => TState;
+
+class Store<TState> {
+	constructor(private state: TState) {}
+
+	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
+		this.state = action(this.state, payload);
+		return this.state;
+	}
+
+	// ... other methods
+}
+
+const store = new Store({value: 1});
+declare const someExternalData: unknown;
+
+store.execute(state => ({value: state.value + 1}));
+//=> `TPayload` is `void`
+
+store.execute((state, payload) => ({value: state.value + payload}), 5);
+//=> `TPayload` is `5`
+
+store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
+//=> Errors: `action` is `(state: TState) => TState`
+```
+
+@category Utilities
+*/
+export type IsUnknown<T> = (
+	unknown extends T // `T` can be `unknown` or `any`
+		? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
+			? true
+			: false
+		: false
+);

package/node_modules/type-fest/source/iterable-element.d.ts

@@ -0,0 +1,64 @@
+/**
+Get the element type of an `Iterable`/`AsyncIterable`. For example, `Array`, `Set`, `Map`, generator, stream, etc.
+
+This can be useful, for example, if you want to get the type that is yielded in a generator function. Often the return type of those functions are not specified.
+
+This type works with both `Iterable`s and `AsyncIterable`s, so it can be use with synchronous and asynchronous generators.
+
+Here is an example of `IterableElement` in action with a generator function:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+function * iAmGenerator() {
+	yield 1;
+	yield 2;
+}
+
+type MeNumber = IterableElement<ReturnType<typeof iAmGenerator>>
+```
+
+And here is an example with an async generator:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+async function * iAmGeneratorAsync() {
+	yield 'hi';
+	yield true;
+}
+
+type MeStringOrBoolean = IterableElement<ReturnType<typeof iAmGeneratorAsync>>
+```
+
+Many types in JavaScript/TypeScript are iterables. This type works on all types that implement those interfaces.
+
+An example with an array of strings:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+type MeString = IterableElement<string[]>
+```
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+const fruits = new Set(['🍎', '🍌', '🍉'] as const);
+
+type Fruit = IterableElement<typeof fruits>;
+//=> '🍎' | '🍌' | '🍉'
+```
+
+@category Iterable
+*/
+export type IterableElement<TargetIterable> =
+	TargetIterable extends Iterable<infer ElementType> ?
+		ElementType :
+		TargetIterable extends AsyncIterable<infer ElementType> ?
+			ElementType :
+			never;

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

@@ -0,0 +1,68 @@
+// The builtin `join` method supports all these natively in the same way that typescript handles them so we can safely accept all of them.
+type JoinableItem = string | number | bigint | boolean | undefined | null;
+
+// `null` and `undefined` are treated uniquely in the built-in join method, in a way that differs from the default `toString` that would result in the type `${undefined}`. That's why we need to handle it specifically with this helper.
+// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join#description
+type NullishCoalesce<
+	Value extends JoinableItem,
+	Fallback extends string,
+> = Value extends undefined | null ? NonNullable<Value> | Fallback : Value;
+
+/**
+Join an array of strings and/or numbers using the given string as a delimiter.
+
+Use-case: Defining key paths in a nested object. For example, for dot-notation fields in MongoDB queries.
+
+@example
+```
+import type {Join} from 'type-fest';
+
+// Mixed (strings & numbers) items; result is: 'foo.0.baz'
+const path: Join<['foo', 0, 'baz'], '.'> = ['foo', 0, 'baz'].join('.');
+
+// Only string items; result is: 'foo.bar.baz'
+const path: Join<['foo', 'bar', 'baz'], '.'> = ['foo', 'bar', 'baz'].join('.');
+
+// Only number items; result is: '1.2.3'
+const path: Join<[1, 2, 3], '.'> = [1, 2, 3].join('.');
+
+// Only bigint items; result is '1.2.3'
+const path: Join<[1n, 2n, 3n], '.'> = [1n, 2n, 3n].join('.');
+
+// Only boolean items; result is: 'true.false.true'
+const path: Join<[true, false, true], '.'> = [true, false, true].join('.');
+
+// Contains nullish items; result is: 'foo..baz..xyz'
+const path: Join<['foo', undefined, 'baz', null, 'xyz'], '.'> = ['foo', undefined, 'baz', null, 'xyz'].join('.');
+
+// Partial tuple shapes (rest param last); result is: `prefix.${string}`
+const path: Join<['prefix', ...string[]], '.'> = ['prefix'].join('.');
+
+// Partial tuple shapes (rest param first); result is: `${string}.suffix`
+const path: Join<[...string[], 'suffix'], '.'> = ['suffix'].join('.');
+
+// Tuples items with nullish unions; result is '.' | 'hello.' | '.world' | 'hello.world'
+const path: Join<['hello' | undefined, 'world' | null], '.'> = ['hello', 'world'].join('.');
+```
+
+@category Array
+@category Template literal
+*/
+export type Join<
+	Items extends readonly JoinableItem[],
+	Delimiter extends string,
+> = Items extends readonly []
+	? ''
+	: Items extends readonly [JoinableItem?]
+		? `${NullishCoalesce<Items[0], ''>}`
+		: Items extends readonly [
+			infer First extends JoinableItem,
+			...infer Tail extends readonly JoinableItem[],
+		]
+			? `${NullishCoalesce<First, ''>}${Delimiter}${Join<Tail, Delimiter>}`
+			: Items extends readonly [
+				...infer Head extends readonly JoinableItem[],
+				infer Last extends JoinableItem,
+			]
+				? `${Join<Head, Delimiter>}${Delimiter}${NullishCoalesce<Last, ''>}`
+				: string;

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

@@ -0,0 +1,37 @@
+import type {JsonPrimitive} from './basic';
+
+type JsonifiableObject = {[Key in string]?: Jsonifiable} | {toJSON: () => Jsonifiable};
+type JsonifiableArray = readonly Jsonifiable[];
+
+/**
+Matches a value that can be losslessly converted to JSON.
+
+Can be used to type values that you expect to pass to `JSON.stringify`.
+
+`undefined` is allowed in object fields (for example, `{a?: number}`) as a special case even though `JSON.stringify({a: undefined})` is `{}` because it makes this class more widely useful and checking for undefined-but-present values is likely an anti-pattern.
+
+@example
+```
+import type {Jsonifiable} from 'type-fest';
+
+// @ts-expect-error
+const error: Jsonifiable = {
+    map: new Map([['a', 1]]),
+};
+
+JSON.stringify(error);
+//=> {"map": {}}
+
+const good: Jsonifiable = {
+    number: 3,
+    date: new Date(),
+    missing: undefined,
+}
+
+JSON.stringify(good);
+//=> {"number": 3, "date": "2022-10-17T22:22:35.920Z"}
+```
+
+@category JSON
+*/
+export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;

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

@@ -0,0 +1,122 @@
+import type {JsonPrimitive, JsonValue} from './basic';
+import type {EmptyObject} from './empty-object';
+import type {UndefinedToOptional} from './internal';
+import type {IsAny} from './is-any';
+import type {IsNever} from './is-never';
+import type {IsUnknown} from './is-unknown';
+import type {NegativeInfinity, PositiveInfinity} from './numeric';
+import type {TypedArray} from './typed-array';
+import type {UnknownArray} from './unknown-array';
+
+// Note: The return value has to be `any` and not `unknown` so it can match `void`.
+type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
+
+type NeverToNull<T> = IsNever<T> extends true ? null : T;
+type UndefinedToNull<T> = T extends undefined ? null : T;
+
+// Handles tuples and arrays
+type JsonifyList<T extends UnknownArray> = T extends readonly []
+	? []
+	: T extends readonly [infer F, ...infer R]
+		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
+		: IsUnknown<T[number]> extends true
+			? []
+			: Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
+
+type FilterJsonableKeys<T extends object> = {
+	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
+}[keyof T];
+
+/**
+JSON serialize objects (not including arrays) and classes.
+*/
+type JsonifyObject<T extends object> = {
+	[Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
+};
+
+/**
+Transform a type to one that is assignable to the `JsonValue` type.
+
+This includes:
+1. Transforming JSON `interface` to a `type` that is assignable to `JsonValue`.
+2. Transforming non-JSON value that is *jsonable* to a type that is assignable to `JsonValue`, where *jsonable* means the non-JSON value implements the `.toJSON()` method that returns a value that is assignable to `JsonValue`.
+
+@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
+```
+import type {Jsonify, JsonValue} from 'type-fest';
+
+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
+```
+
+Non-JSON values such as `Date` implement `.toJSON()`, so they can be transformed to a value assignable to `JsonValue`:
+
+@example
+```
+import type {Jsonify} from 'type-fest';
+
+const time = {
+	timeValue: new Date()
+};
+
+// `Jsonify<typeof time>` is equivalent to `{timeValue: string}`
+const timeJson = JSON.parse(JSON.stringify(time)) as Jsonify<typeof time>;
+```
+
+@link https://github.com/Microsoft/TypeScript/issues/1897#issuecomment-710744173
+
+@category JSON
+*/
+export type Jsonify<T> = IsAny<T> extends true
+	? any
+	: T extends PositiveInfinity | NegativeInfinity
+		? null
+		: T extends JsonPrimitive
+			? T
+			: // Any object with toJSON is special case
+			T extends {toJSON(): infer J}
+				? (() => J) extends () => JsonValue // Is J assignable to JsonValue?
+					? J // Then T is Jsonable and its Jsonable value is J
+					: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
+				: // Instanced primitives are objects
+				T extends Number
+					? number
+					: T extends String
+						? string
+						: T extends Boolean
+							? boolean
+							: T extends Map<any, any> | Set<any>
+								? EmptyObject
+								: T extends TypedArray
+									? Record<string, number>
+									: T extends NotJsonable
+										? never // Non-JSONable type union was found not empty
+										: T extends UnknownArray
+											? JsonifyList<T>
+											: T extends object
+												? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
+												: never; // Otherwise any other non-object is removed

package/node_modules/type-fest/source/kebab-case.d.ts

@@ -0,0 +1,44 @@
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
+
+/**
+Convert a string literal to kebab-case.
+
+This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
+
+@example
+```
+import type {KebabCase} from 'type-fest';
+
+// Simple
+
+const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
+
+// Advanced
+
+type KebabCasedProperties<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+interface CliOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: KebabCasedProperties<CliOptions> = {
+	'dry-run': true,
+	'include-file': 'bar.js',
+	foo: 123
+};
+```
+
+@category Change case
+@category Template literal
+*/
+export type KebabCase<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

package/node_modules/type-fest/source/kebab-cased-properties-deep.d.ts

@@ -0,0 +1,63 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
+
+/**
+Convert object properties to kebab case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see KebabCase
+@see KebabCasedProperties
+
+@example
+```
+import type [KebabCasedPropertiesDeep] from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: KebabCasedPropertiesDeep<UserWithFriends> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry',
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike',
+		},
+	],
+};
+
+const splitOnNumbers: KebabCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, {splitOnNumbers: true}> = {
+	'line-1': {
+		'line-2': [
+			{
+				'line-3': 'string',
+			},
+		],
+	},
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

package/node_modules/type-fest/source/kebab-cased-properties.d.ts

@@ -0,0 +1,40 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
+
+/**
+Convert object properties to kebab case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see KebabCase
+@see KebabCasedPropertiesDeep
+
+@example
+```
+import type {KebabCasedProperties} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+const result: KebabCasedProperties<User> = {
+	'user-id': 1,
+	'user-name': 'Tom',
+};
+
+const splitOnNumbers: KebabCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
+	'line-1': 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

package/node_modules/type-fest/source/keys-of-union.d.ts

@@ -0,0 +1,42 @@
+import type {UnionToIntersection} from './union-to-intersection';
+
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+export type KeysOfUnion<ObjectType> =
+  // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+  keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;

package/node_modules/type-fest/source/last-array-element.d.ts

@@ -0,0 +1,38 @@
+/**
+Extracts the type of the last element of an array.
+
+Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+
+@example
+```
+import type {LastArrayElement} from 'type-fest';
+
+declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+
+const array = ['foo', 2];
+
+typeof lastOf(array);
+//=> number
+
+const array = ['foo', 2] as const;
+
+typeof lastOf(array);
+//=> 2
+```
+
+@category Array
+@category Template literal
+*/
+export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> =
+	// If the last element of an array is a spread element, the `LastArrayElement` result should be `'the type of the element before the spread element' | 'the type of the spread element'`.
+	Elements extends readonly []
+		? ElementBeforeTailingSpreadElement
+		: Elements extends readonly [...infer U, infer V]
+			? V
+			: Elements extends readonly [infer U, ...infer V]
+				// If we return `V[number] | U` directly, it would be wrong for `[[string, boolean, object, ...number[]]`.
+				// So we need to recurse type `V` and carry over the type of the element before the spread element.
+				? LastArrayElement<V, U>
+				: Elements extends ReadonlyArray<infer U>
+					? U | ElementBeforeTailingSpreadElement
+					: never;

package/node_modules/type-fest/source/less-than-or-equal.d.ts

@@ -0,0 +1,22 @@
+import type {GreaterThan} from './greater-than';
+
+/**
+ Returns a boolean for whether a given number is less than or equal to another number.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+LessThanOrEqual<1, -5>;
+//=> false
+
+LessThanOrEqual<1, 1>;
+//=> true
+
+LessThanOrEqual<1, 5>;
+//=> true
+```
+*/
+export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThan<A, B> extends true ? false : true;

package/node_modules/type-fest/source/less-than.d.ts

@@ -0,0 +1,26 @@
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+
+/**
+Returns a boolean for whether a given number is less than another number.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+LessThan<1, -5>;
+//=> false
+
+LessThan<1, 1>;
+//=> false
+
+LessThan<1, 5>;
+//=> true
+```
+*/
+export type LessThan<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThanOrEqual<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen

package/node_modules/type-fest/source/literal-to-primitive-deep.d.ts

@@ -0,0 +1,36 @@
+import type {LiteralToPrimitive} from './literal-to-primitive';
+import type {OmitIndexSignature} from './omit-index-signature';
+
+/**
+Like `LiteralToPrimitive` except it converts literal types inside an object or array deeply.
+
+For example, given a constant object, it returns a new object type with the same keys but with all the values converted to primitives.
+
+@see LiteralToPrimitive
+
+Use-case: Deal with data that is imported from a JSON file.
+
+@example
+```
+import type {LiteralToPrimitiveDeep, TsConfigJson} from 'type-fest';
+import tsconfig from 'path/to/tsconfig.json';
+
+function doSomethingWithTSConfig(config: LiteralToPrimitiveDeep<TsConfigJson>) { ... }
+
+// No casting is needed to pass the type check
+doSomethingWithTSConfig(tsconfig);
+
+// If LiteralToPrimitiveDeep is not used, you need to cast the imported data like this:
+doSomethingWithTSConfig(tsconfig as TsConfigJson);
+```
+
+@category Type
+@category Object
+*/
+export type LiteralToPrimitiveDeep<T> = T extends object
+	? T extends Array<infer U>
+		? Array<LiteralToPrimitiveDeep<U>>
+		: {
+			[K in keyof OmitIndexSignature<T>]: LiteralToPrimitiveDeep<T[K]>;
+		}
+	: LiteralToPrimitive<T>;