@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/tuple-of.d.ts

@@ -0,0 +1,114 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create a tuple type of the specified length with elements of the specified type.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type RGB = TupleOf<3, number>;
+//=> [number, number, number]
+
+type Line = TupleOf<2, {x: number; y: number}>;
+//=> [{x: number; y: number}, {x: number; y: number}]
+
+type TicTacToeBoard = TupleOf<3, TupleOf<3, 'X' | 'O' | null>>;
+//=> [['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null]]
+```
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
+
+type ZeroToFour = Range<0, 5>;
+//=> '0' | '1' | '2' | '3' | '4'
+
+type ThreeToEight = Range<3, 9>;
+//=> '3' | '4' | '5' | '6' | '7' | '8'
+```
+
+Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type StringArray = TupleOf<number, string>;
+//=> string[]
+```
+
+Note: If the type for elements is not specified, it will default to `unknown`.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type UnknownTriplet = TupleOf<3>;
+//=> [unknown, unknown, unknown]
+```
+
+Note: If the specified length is negative, the result will be an empty tuple.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type EmptyTuple = TupleOf<-3, string>;
+//=> []
+```
+
+Note: If the specified length has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type DecimalLength = TupleOf<3.5, string>;
+//=> [string, string, string]
+```
+
+Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for example, to create `readonly [number, number, number]` use `Readonly<TupleOf<3, number>>`.
+
+@category Array
+*/
+export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, {
+	ifNot: _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>;
+	ifAny: Fill[];
+	ifNever: [];
+}>;
+
+type _TupleOf<Length extends number, Fill> = number extends Length
+	? Fill[]
+	: BuildTupleDigitByDigit<`${Length}`, Fill>;
+
+type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> =
+	Length extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildTupleDigitByDigit<Rest, Fill, [...RepeatTupleTenTimes<Accumulator>, ...DigitTupleOf<First, Fill>]>
+		: Accumulator;
+
+type RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+];
+
+type DigitTupleOf<Digit extends DigitCharacter, Fill> = [
+	[],
+	[Fill],
+	[Fill, Fill],
+	[Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+][Digit];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/tuple-to-object.d.ts

@@ -0,0 +1,47 @@
+import type {IsTuple} from './is-tuple.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {If} from './if.d.ts';
+
+/**
+Transforms a tuple into an object, mapping each tuple index to its corresponding type as a key-value pair.
+
+Note: Tuple labels are [lost in the transformation process](https://stackoverflow.com/a/70398429/11719314). For example, `TupleToObject<[x: number, y: number]>` produces `{0: number; 1: number}`, and not `{x: number; y: number}`.
+
+@example
+```
+import type {TupleToObject} from 'type-fest';
+
+type Example1 = TupleToObject<[number, string, boolean]>;
+//=> {0: number; 1: string; 2: boolean}
+
+// Tuples with optional indices
+type Example2 = TupleToObject<[number, string?, boolean?]>;
+//=> {0: number; 1?: string; 2?: boolean}
+
+// Readonly tuples
+type Example3 = TupleToObject<readonly [number, string?]>;
+//=> {readonly 0: number; readonly 1?: string}
+
+// Non-tuple arrays get transformed into index signatures
+type Example4 = TupleToObject<string[]>;
+//=> {[x: number]: string}
+
+// Tuples with rest elements
+type Example5 = TupleToObject<[number, string, ...boolean[]]>;
+//=> {[x: number]: string | number | boolean; 0: number; 1: string}
+
+// Tuple labels are not preserved
+type Example6 = TupleToObject<[x: number, y: number]>;
+//=> {0: number; 1: number}
+```
+
+@category Array
+*/
+export type TupleToObject<TArray extends UnknownArray> = If<IsAny<TArray>, any, {
+	[
+	Key in keyof TArray as Key & (`${number}` | (IsTuple<TArray> extends true ? never : number))
+	]: TArray[Key];
+}>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/tuple-to-union.d.ts

@@ -0,0 +1,54 @@
+/**
+Convert a tuple/array into a union type of its elements.
+
+This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
+
+@example
+```
+import type {TupleToUnion} from 'type-fest';
+
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = TupleToUnion<typeof destinations>;
+//=> 'a' | 'b' | 'c'
+
+function verifyDestination(destination: unknown): destination is Destination {
+	return destinations.includes(destination as any);
+}
+
+type RequestBody = {
+	deliverTo: Destination;
+};
+
+function verifyRequestBody(body: unknown): body is RequestBody {
+	const {deliverTo} = (body as any);
+	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
+}
+```
+
+Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
+
+@example
+```
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = typeof destinations[number];
+//=> 'a' | 'b' | 'c'
+
+const erroringType = new Set(['a', 'b', 'c']);
+
+// @ts-expect-error
+type ErroringType = typeof erroringType[number];
+// Error: Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
+
+const numberBool: {[n: number]: boolean} = {1: true};
+
+type NumberBool = typeof numberBool[number];
+//=> boolean
+```
+
+@category Array
+*/
+export type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/typed-array.d.ts

@@ -0,0 +1,19 @@
+/**
+Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+
+@category Array
+*/
+export type TypedArray =
+	| Int8Array
+	| Uint8Array
+	| Uint8ClampedArray
+	| Int16Array
+	| Uint16Array
+	| Int32Array
+	| Uint32Array
+	| Float32Array
+	| Float64Array
+	| BigInt64Array
+	| BigUint64Array;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/undefined-on-partial-deep.d.ts

@@ -0,0 +1,83 @@
+import type {BuiltIns} from './internal/index.d.ts';
+
+/**
+Create a deep version of another type where all optional keys are set to also accept `undefined`.
+
+Note: This is only needed when the [`exactOptionalPropertyTypes`](https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes) TSConfig setting is enabled.
+
+Use-cases:
+- When `exactOptionalPropertyTypes` is enabled, an object like `{a: undefined}` is not assignable to the type `{a?: number}`. You can use `UndefinedOnPartialDeep<{a?: number}>` to make it assignable.
+
+@example
+```
+import type {UndefinedOnPartialDeep} from 'type-fest';
+
+type Settings = {
+	optionA: string;
+	optionB?: number;
+	subOption: {
+		subOptionA: boolean;
+		subOptionB?: boolean;
+	};
+};
+
+const testSettingsA: Settings = {
+	optionA: 'foo',
+	optionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true.
+	// @ts-expect-error
+	subOption: {
+		subOptionA: true,
+		subOptionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true
+	},
+};
+
+const testSettingsB: UndefinedOnPartialDeep<Settings> = {
+	optionA: 'foo',
+	optionB: undefined, // `optionB` can be set to `undefined` now.
+	subOption: {
+		subOptionA: true,
+		subOptionB: undefined, // `subOptionB` can be set to `undefined` now.
+	},
+};
+```
+*/
+export type UndefinedOnPartialDeep<T> =
+	// Handle built-in type and function
+	T extends BuiltIns | Function
+		? T
+		// Handle tuple and array
+		: T extends readonly unknown[]
+			? UndefinedOnPartialList<T>
+			// Handle map and readonly map
+			: T extends Map<infer K, infer V>
+				? Map<K, UndefinedOnPartialDeep<V>>
+				: T extends ReadonlyMap<infer K, infer V>
+					? ReadonlyMap<K, UndefinedOnPartialDeep<V>>
+					// Handle set and readonly set
+					: T extends Set<infer K>
+						? Set<UndefinedOnPartialDeep<K>>
+						: T extends ReadonlySet<infer K>
+							? ReadonlySet<UndefinedOnPartialDeep<K>>
+							// Handle object
+							: T extends Record<any, any>
+								? {
+									[KeyType in keyof T]: undefined extends T[KeyType]
+										? UndefinedOnPartialDeep<T[KeyType]> | undefined
+										: UndefinedOnPartialDeep<T[KeyType]>
+								}
+								: T; // If T is not builtins / function / array / map / set / object, return T
+
+// Handle tuples and arrays
+type UndefinedOnPartialList<T extends readonly unknown[]> = T extends []
+	? []
+	: T extends [infer F, ...infer R]
+		? [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
+		: T extends readonly [infer F, ...infer R]
+			? readonly [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
+			: T extends Array<infer F>
+				? Array<UndefinedOnPartialDeep<F>>
+				: T extends ReadonlyArray<infer F>
+					? ReadonlyArray<UndefinedOnPartialDeep<F>>
+					: never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/union-length.d.ts

@@ -0,0 +1,27 @@
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+
+/**
+Returns the length of a union type.
+
+@example
+```
+import type {UnionLength} from 'type-fest';
+
+type T1 = UnionLength<'foo' | 'bar' | 'baz'>;
+//=> 3
+
+type T2 = UnionLength<[string, string, string] | {x: string; y: string; z: string}>;
+//=> 2
+
+type T3 = UnionLength<any>;
+//=> 1
+
+type T4 = UnionLength<never>;
+//=> 0
+```
+
+@category Type
+*/
+export type UnionLength<Union> = UnionToTuple<Union>['length'];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/union-member.d.ts

@@ -0,0 +1,65 @@
+import type {UnionToIntersection} from './union-to-intersection.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Returns an arbitrary member of a union type.
+
+Use-cases:
+- Implementing recursive type functions that accept a union type.
+
+@example
+```
+import type {UnionMember, IsNever} from 'type-fest';
+
+type UnionLength<T, Acc extends any[] = []> =
+	UnionMember<T> extends infer Member
+		? IsNever<Member> extends false
+			? UnionLength<Exclude<T, Member>, [...Acc, Member]>
+			: Acc['length']
+		: never;
+
+type T1 = UnionLength<'foo' | 'bar' | 'baz'>;
+//=> 3
+
+type T2 = UnionLength<{a: string}>;
+//=> 1
+```
+
+- Picking an arbitrary member from a union
+
+@example
+```
+import type {UnionMember, Primitive, LiteralToPrimitive} from 'type-fest';
+
+type IsHomogenous<T extends Primitive> = [T] extends [LiteralToPrimitive<UnionMember<T>>] ? true : false;
+
+type T1 = IsHomogenous<1 | 2 | 3 | 4>;
+//=> true
+
+type T2 = IsHomogenous<'foo' | 'bar'>;
+//=> true
+
+type T3 = IsHomogenous<'foo' | 'bar' | 1>;
+//=> false
+```
+
+Returns `never` when the input is `never`.
+
+@example
+```
+import type {UnionMember} from 'type-fest';
+
+type LastNever = UnionMember<never>;
+//=> never
+```
+
+@category Type
+*/
+export type UnionMember<T> =
+	IsNever<T> extends true
+		? never
+		: UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
+			? R
+			: never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -0,0 +1,35 @@
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+export type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void)
+	// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+	? Intersection & Union
+	: never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/union-to-tuple.d.ts

@@ -0,0 +1,49 @@
+import type {ExcludeExactly} from './exclude-exactly.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {UnionMember} from './union-member.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Convert a union type into an unordered tuple type of its elements.
+
+"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
+
+This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
+
+@example
+```
+import type {UnionToTuple} from 'type-fest';
+
+type Numbers = 1 | 2 | 3;
+type NumbersTuple = UnionToTuple<Numbers>;
+//=> [1, 2, 3]
+```
+
+@example
+```
+import type {UnionToTuple} from 'type-fest';
+
+const pets = {
+	dog: '🐶',
+	cat: '🐱',
+	snake: '🐍',
+};
+
+type Pet = keyof typeof pets;
+//=> 'dog' | 'cat' | 'snake'
+
+const petList = Object.keys(pets) as UnionToTuple<Pet>;
+//=> ['dog', 'cat', 'snake']
+```
+
+@category Array
+*/
+export type UnionToTuple<Union> =
+	_UnionToTuple<Union> extends infer Result extends UnknownArray ? Result : never; // Nudges the compiler that `UnionToTuple` always yields an array.
+
+type _UnionToTuple<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> =
+	IsNever<Union> extends true
+		? Accumulator
+		: _UnionToTuple<ExcludeExactly<Union, Member>, [Member, ...Accumulator]>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unknown-array.d.ts

@@ -0,0 +1,27 @@
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+export type UnknownArray = readonly unknown[];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unknown-map.d.ts

@@ -0,0 +1,26 @@
+/**
+Represents a map with `unknown` key and value.
+
+Use case: You want a type that all maps can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownMap} from 'type-fest';
+
+type IsMap<T> = T extends UnknownMap ? true : false;
+
+type A = IsMap<Map<string, number>>;
+//=> true
+
+type B = IsMap<ReadonlyMap<number, string>>;
+//=> true
+
+type C = IsMap<string>;
+//=> false
+```
+
+@category Type
+*/
+export type UnknownMap = ReadonlyMap<unknown, unknown>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unknown-record.d.ts

@@ -0,0 +1,33 @@
+/**
+Represents an object with `unknown` value. You probably want this instead of `{}`.
+
+Use case: You have an object whose keys and values are unknown to you.
+
+@example
+```
+import type {UnknownRecord} from 'type-fest';
+
+function toJson(object: UnknownRecord) {
+	return JSON.stringify(object);
+}
+
+toJson({hello: 'world'}); // Ok
+
+function isObject(value: unknown): value is UnknownRecord {
+	return typeof value === 'object' && value !== null;
+}
+
+const value: unknown = {hello: 'world'};
+
+if (isObject(value)) {
+	const v = value;
+	//=> UnknownRecord
+}
+```
+
+@category Type
+@category Object
+*/
+export type UnknownRecord = Record<PropertyKey, unknown>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unknown-set.d.ts

@@ -0,0 +1,26 @@
+/**
+Represents a set with `unknown` value.
+
+Use case: You want a type that all sets can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownSet} from 'type-fest';
+
+type IsSet<T> = T extends UnknownSet ? true : false;
+
+type A = IsSet<Set<string>>;
+//=> true
+
+type B = IsSet<ReadonlySet<number>>;
+//=> true
+
+type C = IsSet<string>;
+//=> false
+```
+
+@category Type
+*/
+export type UnknownSet = ReadonlySet<unknown>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unwrap-partial.d.ts

@@ -0,0 +1,33 @@
+/**
+Revert the `Partial` modifier on an object type.
+
+Use-case: Infer the underlying type `T` when only `Partial<T>` is available or the original type may not be directly accessible.
+
+@example
+```
+import type {UnwrapPartial} from 'type-fest';
+
+type Config = Partial<{
+	port: number;
+	host: string;
+	secure?: boolean;
+}>;
+
+type InitializedConfig = UnwrapPartial<Config>;
+//=> {port: number; host: string; secure?: boolean}
+```
+
+Note: If the provided type isn’t of `Partial<T>`, `UnwrapPartial` has no effect on the original type.
+
+@category Object
+*/
+export type UnwrapPartial<PartialObjectType> =
+	PartialObjectType extends Partial<infer ObjectType>
+		? (
+			Partial<ObjectType> extends PartialObjectType
+				? ObjectType
+				: PartialObjectType
+		)
+		: PartialObjectType;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/unwrap-required.d.ts

@@ -0,0 +1,37 @@
+import type {MapsSetsOrArrays, NonRecursiveType} from './internal/type.d.ts';
+
+/**
+Revert the `Required` modifier on an object type.
+
+Use-case: Infer the underlying type `T` when only `Required<T>` is available or the original type may not be directly accessible.
+
+@example
+```
+import type {UnwrapRequired} from 'type-fest';
+
+type ContactFormData = Required<{
+	email: string;
+	message?: string;
+}>;
+
+type DraftContactFormData = UnwrapRequired<ContactFormData>;
+//=> {email: string; message?: string}
+```
+
+Note:
+	- If the provided type isn’t of the form `Required<T>`, `UnwrapRequired` simply returns the input type.
+	- `UnwrapRequired` doesn't work with arrays, if instantiated with arrays, it simply returns the input type.
+
+@category Object
+*/
+export type UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends NonRecursiveType | MapsSetsOrArrays
+		? RequiredObjectType
+		: _UnwrapRequired<RequiredObjectType>;
+
+type _UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends Required<infer ObjectType>
+		? ObjectType
+		: RequiredObjectType;
+
+export {};