@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -0,0 +1,37 @@
+import type {JsonPrimitive} from './json-value.d.ts';
+
+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]]),
+};
+
+console.log(JSON.stringify(error)); // {"map": {}}
+
+const good: Jsonifiable = {
+	number: 3,
+	date: new Date('2025-12-25'),
+	missing: undefined,
+};
+
+console.log(JSON.stringify(good)); // {"number": 3, "date": "2025-12-25T00:00:00.000Z"}
+```
+
+@category JSON
+*/
+export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;
+
+export {};

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

@@ -0,0 +1,127 @@
+import type {JsonPrimitive, JsonValue} from './json-value.d.ts';
+import type {EmptyObject} from './empty-object.d.ts';
+import type {UndefinedToOptional} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+import type {TypedArray} from './typed-array.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+// 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]
+		? [F, ...R] extends T // With TS 5.8.3, if `string[] & ['foo']`, `R` is `unknown[]` here, making the inferred types not equal to the original one
+			? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
+			: [NeverToNull<Jsonify<F>>]
+		: IsUnknown<T[number]> extends true
+			? JsonValue[]
+			: 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 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],
+};
+
+declare function problemFn(data: JsonValue): void;
+
+// @ts-expect-error
+problemFn(point); // Error: type Geometry is not assignable to parameter of type JsonValue because it is an interface
+
+declare function fixedFn<T>(data: Jsonify<T>): void;
+
+fixedFn(point); // Good: point is assignable. Jsonify<T> transforms Geometry into value assignable to JsonValue
+
+// @ts-expect-error
+fixedFn(new Date()); // Error: As expected, Date is not assignable. Jsonify<T> cannot transform Date into a 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
+												: IsUnknown<T> extends true
+													? JsonValue
+													: never; // Otherwise any other non-object is removed
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/kebab-case.d.ts

@@ -0,0 +1,47 @@
+import type {_DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
+
+/**
+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';
+const someVariableWithPunctuation: KebabCase<'div.card::after', {splitOnPunctuation: true}> = 'div-card-after';
+
+// Advanced
+
+type KebabCasedProperties<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+type 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>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/kebab-cased-properties-deep.d.ts

@@ -0,0 +1,72 @@
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
+
+/**
+Convert object properties to kebab case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link KebabCase}
+@see {@link KebabCasedProperties}
+
+@example
+```
+import type {KebabCasedPropertiesDeep} from 'type-fest';
+
+type User = {
+	userId: number;
+	userName: string;
+};
+
+type 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',
+			},
+		],
+	},
+};
+
+const splitOnPunctuation: KebabCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/kebab-cased-properties.d.ts

@@ -0,0 +1,46 @@
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
+
+/**
+Convert top-level object properties to kebab case.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link KebabCase}
+@see {@link KebabCasedPropertiesDeep}
+
+@example
+```
+import type {KebabCasedProperties} from 'type-fest';
+
+type 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',
+};
+
+const splitOnPunctuation: KebabCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	'foo-bar': 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/key-as-string.d.ts

@@ -0,0 +1,27 @@
+/**
+Get keys of the given type as strings.
+
+Number keys are converted to strings.
+
+Use-cases:
+- Get string keys from a type which may have number keys.
+- Makes it possible to index using strings retrieved from template types.
+
+@example
+```
+import type {KeyAsString} from 'type-fest';
+
+type Foo = {
+	1: number;
+	stringKey: string;
+};
+
+type StringKeysOfFoo = KeyAsString<Foo>;
+//=> 'stringKey' | '1'
+```
+
+@category Object
+*/
+export type KeyAsString<BaseType> = `${Extract<keyof BaseType, string | number>}`;
+
+export {};

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

@@ -0,0 +1,44 @@
+import type {UnionToIntersection} from './union-to-intersection.d.ts';
+
+/**
+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>;
+
+export {};

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

@@ -0,0 +1,89 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+import type {SplitOnRestElement} from './split-on-rest-element.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extract 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<const V extends readonly any[]>(array: V): LastArrayElement<V>;
+
+const last1 = lastOf(['foo', 'bar']);
+//=> 'bar'
+
+const last2 = lastOf([true, false, 'baz', 10]);
+//=> 10
+```
+
+Note: When the array ends with an optional or rest element, the last element's position becomes ambiguous. In such cases, the result is a union of the types of all elements that could potentially be the last element of the array.
+
+@example
+```
+import type {LastArrayElement} from 'type-fest';
+
+type A = LastArrayElement<[string, number?, bigint?]>;
+//=> bigint | number | string
+
+type B = LastArrayElement<[string, number, bigint?, ...boolean[]]>;
+//=> boolean | bigint | number
+```
+
+Note: If empty array is a valid value for the array type, the result includes an `undefined`. This aligns with the runtime behavior of `[].at(-1)`.
+
+@example
+```
+import type {LastArrayElement} from 'type-fest';
+
+type A = LastArrayElement<[]>;
+//=> undefined
+
+// `[]` is assignable to `string[]`
+type B = LastArrayElement<string[]>;
+//=> string | undefined
+
+// `[]` is assignable to `[string?, number?]`
+type C = LastArrayElement<[string?, number?]>;
+//=> number | string | undefined
+
+// `[]` is assignable to [string?, number?, ...bigint[]]`
+type D = LastArrayElement<[string?, number?, ...bigint[]]>;
+//=> bigint | number | string | undefined
+```
+
+@category Array
+@category Template literal
+*/
+export type LastArrayElement<TArray extends UnknownArray> =
+	IfNotAnyOrNever<TArray, {
+		ifNot: TArray extends UnknownArray // For distributing `TArray`
+			? SplitOnRestElement<TArray> extends readonly [infer BeforeRest extends UnknownArray, infer Rest extends UnknownArray, infer AfterRest extends UnknownArray]
+				? _LastArrayElement<BeforeRest, Rest, AfterRest>
+				: never
+			: never;
+	}>;
+
+type _LastArrayElement<BeforeRest extends UnknownArray, Rest extends UnknownArray, AfterRest extends UnknownArray> =
+	AfterRest extends readonly [...any, infer Last] // Note there are no optional elements in `AfterRest`.
+		? Last // If there's a `Last` in `AfterRest`, then that's the result.
+		: Rest[number] | BeforeRestLastElement<BeforeRest>; // Otherwise, the result is union of the `Rest` element and the last element in `BeforeRest`.
+
+type BeforeRestLastElement<BeforeRest extends UnknownArray, Accumulator = never> =
+	BeforeRest extends readonly []
+		? Accumulator | undefined
+		: BeforeRest extends readonly [...any, infer Last]
+			? Last | Accumulator
+			: BeforeRest extends readonly [...infer Rest, (infer Last)?]
+				? BeforeRestLastElement<
+					Rest,
+					// Add `undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+					Last | Accumulator | If<IsExactOptionalPropertyTypesEnabled, never, undefined>
+				>
+				: never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/less-than-or-equal.d.ts

@@ -0,0 +1,60 @@
+import type {GreaterThan} from './greater-than.d.ts';
+
+/**
+Returns a boolean for whether a given number is less than or equal to another number.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+type A = LessThanOrEqual<1, -5>;
+//=> false
+
+type B = LessThanOrEqual<1, 1>;
+//=> true
+
+type C = LessThanOrEqual<1, 5>;
+//=> true
+```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+type A = LessThanOrEqual<number, 1>;
+//=> boolean
+
+type B = LessThanOrEqual<1, number>;
+//=> boolean
+
+type C = LessThanOrEqual<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+// Use `LessThanOrEqual` to constrain a function parameter to non-positive numbers.
+declare function setNonPositive<N extends number>(value: LessThanOrEqual<N, 0> extends true ? N : never): void;
+
+setNonPositive(0); // ✅ Allowed
+setNonPositive(-1); // ✅ Allowed
+
+// @ts-expect-error
+setNonPositive(1);
+
+// @ts-expect-error
+setNonPositive(2);
+```
+*/
+export type LessThanOrEqual<A extends number, B extends number> =
+	GreaterThan<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/less-than.d.ts

@@ -0,0 +1,60 @@
+import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
+
+/**
+Returns a boolean for whether a given number is less than another number.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<1, -5>;
+//=> false
+
+type B = LessThan<1, 1>;
+//=> false
+
+type C = LessThan<1, 5>;
+//=> true
+```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<number, 1>;
+//=> boolean
+
+type B = LessThan<1, number>;
+//=> boolean
+
+type C = LessThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+// Use `LessThan` to constrain a function parameter to negative numbers.
+declare function setNegative<N extends number>(value: LessThan<N, 0> extends true ? N : never): void;
+
+setNegative(-1); // ✅ Allowed
+setNegative(-2); // ✅ Allowed
+
+// @ts-expect-error
+setNegative(0);
+
+// @ts-expect-error
+setNegative(1);
+```
+*/
+export type LessThan<A extends number, B extends number> =
+	GreaterThanOrEqual<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/literal-to-primitive-deep.d.ts

@@ -0,0 +1,71 @@
+import type {LiteralToPrimitive} from './literal-to-primitive.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+
+/**
+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 {@link LiteralToPrimitive}
+
+Use-case: Deal with data that is imported from a JSON file.
+
+@example
+```
+import type {LiteralToPrimitiveDeep} from 'type-fest';
+
+const config = {
+	appName: 'MyApp',
+	version: '1.0.0',
+	maxRetries: 3,
+	enableLogging: true,
+	apiUrl: 'https://api.myapp.com/v1',
+} as const;
+
+declare function updateConfig(newConfig: typeof config): void;
+
+updateConfig({
+	// @ts-expect-error
+	appName: 'MyUpdatedApp',
+	// Error: Type '"MyUpdatedApp"' is not assignable to type '"MyApp"'.
+
+	// @ts-expect-error
+	version: '2.0.0',
+	// Error: Type '"2.0.0"' is not assignable to type '"1.0.0"'.
+
+	// @ts-expect-error
+	maxRetries: 1,
+	// Error: Type '1' is not assignable to type '3'.
+
+	// @ts-expect-error
+	enableLogging: false,
+	// Error: Type 'false' is not assignable to type 'true'.
+
+	// @ts-expect-error
+	apiUrl: 'https://api.myapp.com/v2',
+	// Error: Type '"https://api.myapp.com/v2"' is not assignable to type '"https://api.myapp.com/v1"'.
+});
+
+declare function updateConfigFixed(newConfig: LiteralToPrimitiveDeep<typeof config>): void;
+
+updateConfigFixed({
+	appName: 'MyUpdatedApp',
+	version: '2.0.0',
+	maxRetries: 1,
+	enableLogging: false,
+	apiUrl: 'https://api.myapp.com/v2',
+});
+```
+
+@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>;
+
+export {};