@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

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

@@ -0,0 +1,85 @@
+declare const invariantBrand: unique symbol;
+
+/**
+Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
+
+Use-case:
+- Prevent runtime errors that may occur due to assigning subtypes to supertypes.
+- Improve type signature of object methods like [`Object.keys()` or `Object.entries()`](https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208) by sealing the object type.
+
+@example
+```
+import type {InvariantOf} from 'type-fest';
+
+class Animal {
+	constructor(public name: string) {}
+}
+
+class Cat extends Animal {
+	meow() {
+		// do something
+	}
+}
+
+let animalArray: Animal[] = [new Animal('jerry')];
+const catArray: Cat[] = [new Cat('tom')];
+
+animalArray = catArray; // Okay if covariant
+animalArray.push(new Animal('another animal')); // Pushed an animal into catArray
+for (const c of catArray) {
+	c.meow();
+} // Allowed but, error at runtime
+
+let invariantAnimalArray: Array<InvariantOf<Animal>> = [new Animal('jerry')] as Array<InvariantOf<Animal>>;
+const invariantCatArray: Array<InvariantOf<Cat>> = [new Cat('tom')] as Array<InvariantOf<Cat>>;
+
+// @ts-expect-error
+invariantAnimalArray = invariantCatArray; // Error: Type 'InvariantOf<Cat>[]' is not assignable to type 'InvariantOf<Animal>[]'.
+```
+
+@example
+```
+import type {InvariantOf} from 'type-fest';
+
+// In covariance (default)
+
+type FooBar = {
+	foo: number;
+	bar: string;
+};
+
+type FooBarBaz = {
+	baz: boolean;
+} & FooBar;
+
+declare const fooBar: FooBar;
+declare const fooBarBaz: FooBarBaz;
+
+function keyOfFooBar(fooBar: FooBar) {
+	return Object.keys(fooBar) as Array<keyof FooBar>;
+}
+
+keyOfFooBar(fooBar); //=> (keyof FooBar)[]
+keyOfFooBar(fooBarBaz); //=> (keyof FooBar)[] but, (keyof FooBarBaz)[] at runtime
+
+// In invariance
+
+export function invariantOf<Type>(value: Type): InvariantOf<Type> {
+	return value as InvariantOf<Type>;
+}
+
+function keyOfInvariantFooBar(fooBar: InvariantOf<FooBar>) {
+	return Object.keys(fooBar) as Array<keyof FooBar>;
+}
+
+keyOfInvariantFooBar(invariantOf(fooBar)); // (keyof FooBar)[]
+
+// @ts-expect-error
+keyOfInvariantFooBar(invariantOf(fooBarBaz)); // Error: Argument of type 'InvariantOf<FooBarBaz>' is not assignable to parameter of type 'InvariantOf<FooBar>'.
+```
+
+@category Type
+*/
+export type InvariantOf<Type> = Type & {[invariantBrand]: (_: Type) => Type};
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-any.d.ts

@@ -0,0 +1,31 @@
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-equal.d.ts

@@ -0,0 +1,41 @@
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsEqual<A, B> =
+	[A] extends [B]
+		? [B] extends [A]
+			? _IsEqual<A, B>
+			: false
+		: false;
+
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-float.d.ts

@@ -0,0 +1,43 @@
+/**
+Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
+
+Use-case:
+- If you want to make a conditional branch based on the result of whether a number is a float or not.
+
+@example
+```
+import type {IsFloat, PositiveInfinity} from 'type-fest';
+
+type A = IsFloat<1.5>;
+//=> true
+
+type B = IsFloat<-1.5>;
+//=> true
+
+type C = IsFloat<1e-7>;
+//=> true
+
+type D = IsFloat<1.0>;
+//=> false
+
+type E = IsFloat<PositiveInfinity>;
+//=> false
+
+type F = IsFloat<1.23e+21>;
+//=> false
+```
+
+@category Type Guard
+@category Numeric
+*/
+export type IsFloat<T> = T extends number
+	? `${T}` extends `${number}e${infer E extends '-' | '+'}${number}`
+		? E extends '-'
+			? true
+			: false
+		: `${T}` extends `${number}.${number}`
+			? true
+			: false
+	: false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-integer.d.ts

@@ -0,0 +1,60 @@
+import type {Not} from './internal/index.d.ts';
+import type {IsFloat} from './is-float.d.ts';
+import type {PositiveInfinity, NegativeInfinity} from './numeric.d.ts';
+
+/**
+Returns a boolean for whether the given number is an integer, like `-5`, `1.0`, or `100`.
+
+Use-case:
+- If you want to make a conditional branch based on the result of whether a number is an integer or not.
+
+@example
+```
+import type {IsInteger, PositiveInfinity} from 'type-fest';
+
+type A = IsInteger<1>;
+//=> true
+
+type B = IsInteger<1.0>;
+//=> true
+
+type C = IsInteger<-1>;
+//=> true
+
+type D = IsInteger<0b10>;
+//=> true
+
+type E = IsInteger<0o10>;
+//=> true
+
+type F = IsInteger<0x10>;
+//=> true
+
+type G = IsInteger<1.23e+21>;
+//=> true
+
+type H = IsInteger<1.5>;
+//=> false
+
+type I = IsInteger<PositiveInfinity>;
+//=> false
+
+type J = IsInteger<1e-7>;
+//=> false
+```
+
+@category Type Guard
+@category Numeric
+*/
+export type IsInteger<T> =
+	T extends bigint
+		? true
+		: T extends number
+			? number extends T
+				? false
+				: T extends PositiveInfinity | NegativeInfinity
+					? false
+					: Not<IsFloat<T>>
+			: false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-literal.d.ts

@@ -0,0 +1,317 @@
+import type {Primitive} from './primitive.d.ts';
+import type {_Numeric} from './numeric.d.ts';
+import type {CollapseLiterals, IfNotAnyOrNever, IsNotFalse, IsPrimitive} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {TagContainer, UnwrapTagged} from './tagged.d.ts';
+
+/**
+Returns a boolean for whether the given type `T` is the specified `LiteralType`.
+
+@link https://stackoverflow.com/a/52806744/10292952
+
+@example
+```
+type A = LiteralCheck<1, number>;
+//=> true
+
+type B = LiteralCheck<number, number>;
+//=> false
+
+type C = LiteralCheck<1, string>;
+//=> false
+```
+*/
+type LiteralCheck<T, LiteralType extends Primitive> = (
+	IsNever<T> extends false // Must be wider than `never`
+		? [T] extends [LiteralType & infer U] // Remove any branding
+			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+					? false
+					: true
+				: false
+			: false
+		: false
+);
+
+/**
+Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
+
+@example
+```
+type A = LiteralChecks<1, Numeric>;
+//=> true
+
+type B = LiteralChecks<1n, Numeric>;
+//=> true
+
+type C = LiteralChecks<bigint, Numeric>;
+//=> false
+```
+*/
+type LiteralChecks<T, LiteralUnionType> = (
+	// Conditional type to force union distribution.
+	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+	IsNotFalse<LiteralUnionType extends Primitive
+		? LiteralCheck<T, LiteralUnionType>
+		: never
+	>
+);
+
+/**
+Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed string manipulation functions
+	- constraining strings to be a string literal
+	- type utilities, such as when constructing parsers and ASTs
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+
+// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
+function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
+	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
+}
+
+const output = capitalize('hello, world!');
+//=> 'Hello, world!'
+```
+
+@example
+```
+// String types with infinite set of possible values return `false`.
+
+import type {IsStringLiteral} from 'type-fest';
+
+type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
+//=> false
+
+// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
+
+type Length<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends false
+		? number // return `number` for infinite string types
+		: S extends `${string}${infer Tail}`
+			? Length<Tail, [...Counter, never]>
+			: Counter['length'];
+
+type L1 = Length<Lowercase<string>>;
+//=> number
+
+type L2 = Length<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+	ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+export type _IsStringLiteral<S> =
+// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+// and since `{}` extends index signatures, the result becomes `false`.
+	S extends string
+		? {} extends Record<S, never>
+			? false
+			: true
+		: false;
+
+/**
+Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsNumericLiteral, IsStringLiteral} from 'type-fest';
+
+// https://github.com/inocan-group/inferred-types/blob/master/modules/types/src/boolean-logic/operators/EndsWith.ts
+type EndsWith<TValue, TEndsWith extends string> =
+	TValue extends string
+		? IsStringLiteral<TEndsWith> extends true
+			? IsStringLiteral<TValue> extends true
+				? TValue extends `${string}${TEndsWith}`
+					? true
+					: false
+				: boolean
+			: boolean
+		: TValue extends number
+			? IsNumericLiteral<TValue> extends true
+				? EndsWith<`${TValue}`, TEndsWith>
+				: false
+			: false;
+
+function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
+	return `${input}`.endsWith(end) as EndsWith<Input, End>;
+}
+
+endsWith('abc', 'c');
+//=> true
+
+endsWith(123_456, '456');
+//=> true
+
+const end = '123' as string;
+
+endsWith('abc123', end);
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNumericLiteral<T> = LiteralChecks<T, _Numeric>;
+
+/**
+Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsBooleanLiteral} from 'type-fest';
+
+const id = 123;
+
+type GetId<AsString extends boolean> =
+	IsBooleanLiteral<AsString> extends true
+		? AsString extends true
+			? `${typeof id}`
+			: typeof id
+		: number | string;
+
+function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
+	return (options?.asString ? `${id}` : id) as GetId<AsString>;
+}
+
+const numberId = getId();
+//=> 123
+
+const stringId = getId({asString: true});
+//=> '123'
+
+declare const runtimeBoolean: boolean;
+const eitherId = getId({asString: runtimeBoolean});
+//=> string | number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
+
+/**
+Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsSymbolLiteral} from 'type-fest';
+
+type Get<Object_ extends Record<symbol, number>, Key extends keyof Object_> =
+	IsSymbolLiteral<Key> extends true
+		? Object_[Key]
+		: number;
+
+function get<Object_ extends Record<symbol, number>, Key extends keyof Object_>(o: Object_, key: Key) {
+	return o[key] as Get<Object_, Key>;
+}
+
+const symbolLiteral = Symbol('literal');
+let symbolValue = Symbol('value1');
+symbolValue = Symbol('value2');
+
+get({[symbolLiteral]: 1} as const, symbolLiteral);
+//=> 1
+
+get({[symbolValue]: 1} as const, symbolValue);
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
+
+/** Helper type for `IsLiteral`. */
+type IsLiteralUnion<T> =
+	| IsStringLiteral<T>
+	| IsNumericLiteral<T>
+	| IsBooleanLiteral<T>
+	| IsSymbolLiteral<T>;
+
+/**
+Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsLiteral} from 'type-fest';
+
+type A = IsLiteral<1>;
+//=> true
+
+type B = IsLiteral<number>;
+//=> false
+
+type C = IsLiteral<1n>;
+//=> true
+
+type D = IsLiteral<bigint>;
+//=> false
+
+type E = IsLiteral<'type-fest'>;
+//=> true
+
+type F = IsLiteral<string>;
+//=> false
+
+type G = IsLiteral<`on${string}`>;
+//=> false
+
+declare const symbolLiteral: unique symbol;
+type H = IsLiteral<typeof symbolLiteral>;
+//=> true
+
+type I = IsLiteral<symbol>;
+//=> false
+
+type J = IsLiteral<true>;
+//=> true
+
+type K = IsLiteral<boolean>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsLiteral<T> =
+	IsPrimitive<T> extends true
+		? IsNotFalse<IsLiteralUnion<T>>
+		: false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-lowercase.d.ts

@@ -0,0 +1,38 @@
+import type {AllExtend} from './all-extend.d.ts';
+
+/**
+Returns a boolean for whether the given string literal is lowercase.
+
+@example
+```
+import type {IsLowercase} from 'type-fest';
+
+type A = IsLowercase<'abc'>;
+//=> true
+
+type B = IsLowercase<'Abc'>;
+//=> false
+
+type C = IsLowercase<string>;
+//=> boolean
+```
+*/
+export type IsLowercase<S extends string> = AllExtend<_IsLowercase<S>, true>;
+
+/**
+Loops through each part in the string and returns a boolean array indicating whether each part is lowercase.
+*/
+type _IsLowercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}`
+	? _IsLowercase<Rest, [...Accumulator, IsLowercaseHelper<First>]>
+	: [...Accumulator, IsLowercaseHelper<S>];
+
+/**
+Returns a boolean for whether an individual part of the string is lowercase.
+*/
+type IsLowercaseHelper<S extends string> = S extends Lowercase<string>
+	? true
+	: S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}`
+		? false
+		: boolean;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-never.d.ts

@@ -0,0 +1,56 @@
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/is-null.d.ts

@@ -0,0 +1,22 @@
+/**
+Returns a boolean for whether the given type is `null`.
+
+@example
+```
+import type {IsNull} from 'type-fest';
+
+type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
+
+type Example1 = NonNullFallback<null, string>;
+//=> string
+
+type Example2 = NonNullFallback<number, string>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNull<T> = [T] extends [null] ? true : false;
+
+export {};