@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -0,0 +1,79 @@
+import type {NonRecursiveType} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {IsUnion} from './is-union.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create a type with shared fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
+
+@example
+```
+import type {SharedUnionFields} from 'type-fest';
+
+type Cat = {
+	name: string;
+	type: 'cat';
+	catType: string;
+};
+
+type Dog = {
+	name: string;
+	type: 'dog';
+	dogType: string;
+};
+
+function displayPetInfo(petInfo: Cat | Dog) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
+	// }
+
+	// petInfo type is complex and have some needless fields
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+
+function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// }
+
+	// petInfo type is simple and clear
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+```
+
+@see {@link SharedUnionFieldsDeep}
+@see {@link AllUnionFields}
+
+@category Object
+@category Union
+*/
+export type SharedUnionFields<Union> =
+	Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+		? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+			? // eslint-disable-line @stylistic/operator-linebreak
+			| SkippedMembers
+			| (IsNever<RelevantMembers> extends true
+				? never
+				: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+			: never
+		: never;
+
+export {};

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

@@ -0,0 +1,117 @@
+import type {ConditionalSimplifyDeep} from './conditional-simplify-deep.d.ts';
+import type {MapsSetsOrArrays, NonRecursiveType} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Deeply simplifies an object type.
+
+You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
+
+Useful to flatten the type output to improve type hints shown in editors.
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+type Properties1 = {
+	height: number;
+	position: PositionY;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+};
+
+type Properties = Properties1 & Properties2;
+// In your editor, hovering over `Props` will show the following:
+//
+// type Properties = Properties1 & Properties2;
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
+// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+// };
+```
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+// A complex type that you don't want or need to simplify
+type ComplexType = {
+	a: string;
+	b: 'b';
+	c: number;
+};
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+// You want to simplify all other types
+type Properties1 = {
+	height: number;
+	position: PositionY;
+	foo: ComplexType;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+	foo: ComplexType;
+};
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
+// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
+// show a flattened object with all the properties except `ComplexType`:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+//	foo: ComplexType;
+// };
+```
+
+@see {@link Simplify}
+@category Object
+*/
+export type SimplifyDeep<Type, ExcludeType = never> =
+	ConditionalSimplifyDeep<
+		Type,
+	ExcludeType | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>,
+	object
+	>;
+
+export {};

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

@@ -0,0 +1,61 @@
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/single-key-object.d.ts

@@ -0,0 +1,28 @@
+import type {IsEmptyObject} from './empty-object.d.ts';
+import type {If} from './if.d.ts';
+import type {IsUnion} from './is-union.d.ts';
+
+/**
+Create a type that only accepts an object with a single key.
+
+@example
+```
+import type {SingleKeyObject} from 'type-fest';
+
+declare function someFunction<T>(parameter: SingleKeyObject<T>): void;
+
+someFunction({value: true});
+
+// @ts-expect-error
+someFunction({value: true, otherKey: true});
+// Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
+```
+
+@category Object
+*/
+export type SingleKeyObject<ObjectType> =
+	IsUnion<keyof ObjectType> extends true
+		? never
+		: If<IsEmptyObject<ObjectType>, never, ObjectType>;
+
+export {};

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

@@ -0,0 +1,48 @@
+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 snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a snake-cased SQL column name.
+
+@example
+```
+import type {SnakeCase} from 'type-fest';
+
+// Simple
+
+const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
+const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
+const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
+const splitOnPunctuation: SnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'div_card_after';
+
+// Advanced
+
+type SnakeCasedProperties<T> = {
+	[K in keyof T as SnakeCase<K>]: T[K]
+};
+
+type ModelProps = {
+	isHappy: boolean;
+	fullFamilyName: string;
+	foo: number;
+};
+
+const dbResult: SnakeCasedProperties<ModelProps> = {
+	'is_happy': true,
+	'full_family_name': 'Carla Smith',
+	foo: 123,
+};
+```
+
+@category Change case
+@category Template literal
+*/
+export type SnakeCase<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCase<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/snake-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 snake case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link SnakeCase}
+@see {@link SnakeCasedProperties}
+
+@example
+```
+import type {SnakeCasedPropertiesDeep} from 'type-fest';
+
+type User = {
+	userId: number;
+	userName: string;
+};
+
+type UserWithFriends = {
+	userInfo: User;
+	userFriends: User[];
+};
+
+const result: SnakeCasedPropertiesDeep<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: SnakeCasedPropertiesDeep<{line1: {line2: [{line3: string}]}}, {splitOnNumbers: true}> = {
+	line_1: {
+		line_2: [
+			{
+				line_3: 'string',
+			},
+		],
+	},
+};
+
+const splitOnPunctuation: SnakeCasedPropertiesDeep<{'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 SnakeCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/snake-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 snake case.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link SnakeCase}
+@see {@link SnakeCasedPropertiesDeep}
+
+@example
+```
+import type {SnakeCasedProperties} from 'type-fest';
+
+type User = {
+	userId: number;
+	userName: string;
+};
+
+const result: SnakeCasedProperties<User> = {
+	user_id: 1,
+	user_name: 'Tom',
+};
+
+const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
+	'line_1': 'string',
+};
+
+const splitOnPunctuation: SnakeCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	'foo_bar': 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type SnakeCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

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

@@ -0,0 +1,115 @@
+import type {CollapseRestElement} from './internal/array.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Or} from './or.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+@see {@link SomeExtend}
+*/
+export type SomeExtendOptions = {
+	/**
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {SomeExtend} from 'type-fest';
+
+	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+	//=> false
+
+	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+	//=> true
+
+	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = SomeExtend<[never], any, {strictNever: true}>;
+	//=> true
+
+	type F = SomeExtend<[never], any, {strictNever: false}>;
+	//=> true
+	```
+	*/
+	strictNever?: boolean;
+};
+
+type DefaultSomeExtendOptions = {
+	strictNever: true;
+};
+
+/**
+Returns a boolean for whether some element in an array type extends another type.
+
+@example
+```
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<['1', '2', 3], number>;
+//=> true
+
+type B = SomeExtend<[1, 2, 3], string>;
+//=> false
+
+type C = SomeExtend<[string, number | string], number>;
+//=> boolean
+
+type D = SomeExtend<[true, boolean, true], false>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> boolean
+
+type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
+//=> true
+```
+
+@see {@link SomeExtendOptions}
+
+@category Utilities
+@category Array
+*/
+export type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> =
+	_SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
+	ifNot: TArray extends readonly [infer First, ...infer Rest]
+		? IsNever<First> extends true
+			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
+				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+				? true
+				: _SomeExtend<Rest, Type, Options>
+			: First extends Type
+				? true
+				: _SomeExtend<Rest, Type, Options>
+		: false;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/split-on-rest-element.d.ts

@@ -0,0 +1,108 @@
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
+import type {IsArrayReadonly} from './internal/array.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {If} from './if.d.ts';
+
+/**
+{@link SplitOnRestElement} options.
+*/
+type SplitOnRestElementOptions = {
+	/**
+	Whether to preserve the optional modifier (`?`).
+
+	- When set to `true`, the optional modifiers are preserved as-is. For example:
+		`SplitOnRestElement<[number, string?, ...boolean[]], {preserveOptionalModifier: true}>` returns `[[number, string?], boolean[], []]`.
+
+	- When set to `false`, optional elements like `T?` are transformed to `T | undefined` or simply `T` depending on the `exactOptionalPropertyTypes` compiler option. For example:
+		- With `exactOptionalPropertyTypes` enabled: `SplitOnRestElement<[number, string?, ...boolean[]], {preserveOptionalModifier: false}>` returns `[[number, string], boolean[], []]`
+		- And, with it disabled, the result is: `[[number, string | undefined], boolean[], []]`
+
+	@default true
+	*/
+	preserveOptionalModifier?: boolean;
+};
+
+type DefaultSplitOnRestElementOptions = {
+	preserveOptionalModifier: true;
+};
+
+/**
+Splits an array into three parts, where the first contains all elements before the rest element, the second is the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element itself, and the third contains all elements after the rest element.
+
+Note: If any of the parts are missing, then they will be represented as empty arrays. For example, `SplitOnRestElement<[string, number]>` returns `[[string, number], [], []]`, where parts corresponding to the rest element and elements after it are empty.
+
+By default, the optional modifier (`?`) is preserved.
+See {@link SplitOnRestElementOptions `SplitOnRestElementOptions`}.
+
+@example
+```ts
+import type {SplitOnRestElement} from 'type-fest';
+
+type T1 = SplitOnRestElement<[number, ...string[], boolean]>;
+//=> [[number], string[], [boolean]]
+
+type T2 = SplitOnRestElement<readonly [...boolean[], string]>;
+//=> readonly [[], boolean[], [string]]
+
+type T3 = SplitOnRestElement<[number, string?]>;
+//=> [[number, string?], [], []]
+
+type T4 = SplitOnRestElement<[number, string?], {preserveOptionalModifier: false}>;
+//=> [[number, string], [], []]
+
+type T5 = SplitOnRestElement<readonly [string?, ...number[]], {preserveOptionalModifier: false}>;
+//=> readonly [[string], number[], []]
+```
+
+@see {@link ExtractRestElement}
+@see {@link ExcludeRestElement}
+@category Array
+*/
+export type SplitOnRestElement<
+	Array_ extends UnknownArray,
+	Options extends SplitOnRestElementOptions = {},
+> =
+	Array_ extends unknown // For distributing `Array_`
+		? IfNotAnyOrNever<Array_, {
+			ifNot: _SplitOnRestElement<
+				Array_,
+				ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
+			>;
+		}> extends infer Result extends UnknownArray
+			? If<IsArrayReadonly<Array_>, Readonly<Result>, Result>
+			: never // Should never happen
+		: never; // Should never happen
+
+/**
+Deconstructs an array on its rest element and returns the split portions.
+*/
+export type _SplitOnRestElement<
+	Array_ extends UnknownArray,
+	Options extends Required<SplitOnRestElementOptions>,
+	HeadAcc extends UnknownArray = [],
+	TailAcc extends UnknownArray = [],
+> =
+	keyof Array_ & `${number}` extends never
+		// Enters this branch, if `Array_` is empty (e.g., []),
+		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		? Array_ extends readonly [...infer Rest, infer Last]
+			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
+			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc] // Add the rest element between the accumulated elements.
+		: Array_ extends readonly [(infer First)?, ...infer Rest]
+			? _SplitOnRestElement<
+				Rest, Options,
+				[
+					...HeadAcc,
+					...IsOptionalKeyOf<Array_, '0'> extends true
+						? Options['preserveOptionalModifier'] extends false
+							? [If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>] // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+							: [First?]
+						: [First],
+				],
+				TailAcc
+			> // Accumulate elements that are present before the rest element.
+			: never; // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+
+export {};