@quantiya/codevibe-claude-plugin 2.0.4 → 2.0.5

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

@@ -0,0 +1,112 @@
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+export type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+type DefaultExceptOptions = {
+	requireExactProps: false;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+// @ts-expect-error
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+// errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<'b', never>>
+
+// @ts-expect-error
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> {[x: string]: string; [x: number]: string}
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
+```
+
+@category Object
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
+	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+export {};

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

@@ -0,0 +1,57 @@
+import type {IsNever} from './is-never.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {If} from './if.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
+
+@example
+```
+import type {ExcludeExactly} from 'type-fest';
+
+type TestExclude1 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 1 | 2 | 3
+
+type TestExcludeExactly1 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude2 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExcludeExactly2 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude3 = Exclude<{a: string} | {a: string; b: string}, {a: string}>;
+//=> never
+
+type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string; b: string}
+```
+
+@category Improved Built-in
+*/
+export type ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<Union, {
+		ifNot: _ExcludeExactly<Union, Delete>;
+		// If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+		ifAny: If<IsAny<Delete>, never, Union>;
+		// If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+		ifNever: If<IsNever<Delete>, never, Union>;
+	}>;
+
+type _ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<Delete, {
+		ifNot: Union extends unknown // For distributing `Union`
+			? [Delete extends unknown // For distributing `Delete`
+				? If<IsEqual<Union, Delete>, true, never>
+				: never] extends [never] ? Union : never
+			: never;
+		// If `Delete` is `any` or `never`, then return `Union`,
+		// because `Union` cannot be `any` or `never` here.
+		ifAny: Union;
+		ifNever: Union;
+	}>;
+
+export {};

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

@@ -0,0 +1,40 @@
+import type {SplitOnRestElement} from './split-on-rest-element.d.ts';
+import type {IsArrayReadonly} from './internal/array.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
+
+@example
+```
+import type {ExcludeRestElement} from 'type-fest';
+
+type T1 = ExcludeRestElement<[number, ...string[], string, 'foo']>;
+//=> [number, string, 'foo']
+
+type T2 = ExcludeRestElement<[...boolean[], string]>;
+//=> [string]
+
+type T3 = ExcludeRestElement<[...Array<'foo'>, true]>;
+//=> [true]
+
+type T4 = ExcludeRestElement<[number, string]>;
+//=> [number, string]
+```
+
+@see {@link ExtractRestElement}
+@see {@link SplitOnRestElement}
+@category Array
+*/
+export type ExcludeRestElement<Array_ extends UnknownArray> = IfNotAnyOrNever<Array_, {
+	ifNot: SplitOnRestElement<Array_> extends infer Result
+		? Result extends readonly UnknownArray[]
+			? IsArrayReadonly<Array_> extends true
+				? Readonly<[...Result[0], ...Result[2]]>
+				: [...Result[0], ...Result[2]]
+			: never
+		: never;
+}>;
+
+export {};

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

@@ -0,0 +1,51 @@
+/**
+A stricter version of {@link Exclude<T, U>} that ensures every member of `U` can successfully exclude something from `T`.
+
+For example, `ExcludeStrict<string | number | boolean, number | bigint>` will error because `bigint` cannot exclude anything from `string | number | boolean`.
+
+@example
+```
+// Valid Examples
+import type {ExcludeStrict} from 'type-fest';
+
+type Example1 = ExcludeStrict<{status: 'success'; data: string[]} | {status: 'error'; error: string}, {status: 'success'}>;
+//=> {status: 'error'; error: string}
+
+type Example2 = ExcludeStrict<'xs' | 's' | 'm' | 'l' | 'xl', 'xs' | 's'>;
+//=> 'm' | 'l' | 'xl'
+
+type Example3 = ExcludeStrict<{x: number; y: number} | [number, number], unknown[]>;
+//=> {x: number; y: number}
+```
+
+@example
+```
+// Invalid Examples
+import type {ExcludeStrict} from 'type-fest';
+
+// `'xxl'` cannot exclude anything from `'xs' | 's' | 'm' | 'l' | 'xl'`
+// @ts-expect-error
+type Example1 = ExcludeStrict<'xs' | 's' | 'm' | 'l' | 'xl', 'xl' | 'xxl'>;
+//                                                           ~~~~~~~~~~~~
+// Error: Type "'xl' | 'xxl'" does not satisfy the constraint 'never'.
+
+// `unknown[]` cannot exclude anything from `{x: number; y: number} | {x: string; y: string}`
+// @ts-expect-error
+type Example2 = ExcludeStrict<{x: number; y: number} | {x: string; y: string}, unknown[]>;
+//                                                                             ~~~~~~~~~
+// Error: Type 'unknown[]' does not satisfy the constraint 'never'.
+```
+
+@category Improved Built-in
+*/
+export type ExcludeStrict<
+	T,
+	U extends [U] extends [
+		// Ensure every member of `U` excludes something from `T`
+		U extends unknown ? ([T] extends [Exclude<T, U>] ? never : U) : never,
+	]
+		? unknown
+		: never,
+> = Exclude<T, U>;
+
+export {};

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

@@ -0,0 +1,147 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, MapsSetsOrArrays, NonRecursiveType} from './internal/type.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Ensure mutual exclusivity in object unions by adding other members’ keys as `?: never`.
+
+Use-cases:
+- You want each union member to be exclusive, preventing overlapping object shapes.
+- You want to safely access any property defined across the union without additional type guards.
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type FileConfig = {
+	filePath: string;
+};
+
+type InlineConfig = {
+	content: string;
+};
+
+declare function loadConfig1(options: FileConfig | InlineConfig): void;
+
+// Someone could mistakenly provide both `filePath` and `content`.
+loadConfig1({filePath: './config.json', content: '{ "name": "app" }'}); // No errors
+
+// Use `ExclusifyUnion` to prevent that mistake.
+type Config = ExclusifyUnion<FileConfig | InlineConfig>;
+//=> {
+// 	filePath: string;
+// 	content?: never;
+// } | {
+// 	content: string;
+// 	filePath?: never;
+// }
+
+declare function loadConfig2(options: Config): void;
+
+// @ts-expect-error
+loadConfig2({filePath: './config.json', content: '{ "name": "app" }'});
+// Error: Argument of type '{ filePath: string; content: string; }' is not assignable to parameter of type '{ filePath: string; content?: never; } | { content: string; filePath?: never; }'.
+
+loadConfig2({filePath: './config.json'}); // Ok
+
+loadConfig2({content: '{ "name": "app" }'}); // Ok
+```
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type CardPayment = {
+	amount: number;
+	cardNumber: string;
+};
+
+type PaypalPayment = {
+	amount: number;
+	paypalId: string;
+};
+
+function processPayment1(payment: CardPayment | PaypalPayment) {
+	// @ts-expect-error
+	const details = payment.cardNumber ?? payment.paypalId; // Cannot access `cardNumber` or `paypalId` directly
+}
+
+type Payment = ExclusifyUnion<CardPayment | PaypalPayment>;
+//=> {
+// 	amount: number;
+// 	cardNumber: string;
+// 	paypalId?: never;
+// } | {
+// 	amount: number;
+// 	paypalId: string;
+// 	cardNumber?: never;
+// }
+
+function processPayment2(payment: Payment) {
+	const details = payment.cardNumber ?? payment.paypalId; // Ok
+	//=> string
+}
+```
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type A = ExclusifyUnion<{a: string} | {b: number}>;
+//=> {a: string; b?: never} | {b: number; a?: never}
+
+type B = ExclusifyUnion<{a: string} | {b: number} | {c: boolean}>;
+//=> {
+// 	a: string;
+// 	b?: never;
+// 	c?: never;
+// } | {
+// 	b: number;
+// 	a?: never;
+// 	c?: never;
+// } | {
+// 	c: boolean;
+// 	a?: never;
+// 	b?: never;
+// }
+
+type C = ExclusifyUnion<{a: string; b: number} | {b: string; c: number}>;
+//=> {
+// 	a: string;
+// 	b: number;
+// 	c?: never;
+// } | {
+// 	b: string;
+// 	c: number;
+// 	a?: never;
+// }
+
+type D = ExclusifyUnion<{a?: 1; readonly b: 2} | {d: 4}>;
+//=> {a?: 1; readonly b: 2; d?: never} | {d: 4; a?: never; b?: never}
+```
+
+@category Object
+@category Union
+*/
+export type ExclusifyUnion<Union> = IfNotAnyOrNever<Union, {
+	ifNot: If<IsUnknown<Union>, Union,
+		Extract<Union, NonRecursiveType | MapsSetsOrArrays> extends infer SkippedMembers
+			? SkippedMembers | _ExclusifyUnion<Exclude<Union, SkippedMembers>>
+			: never
+	>;
+}>;
+
+type _ExclusifyUnion<Union, UnionCopy = Union> = Union extends unknown // For distributing `Union`
+	? Simplify<
+		Union & Partial<
+			Record<
+				Exclude<KeysOfUnion<UnionCopy>, keyof Union>,
+				never
+			>
+		>
+	>
+	: never; // Should never happen
+
+export {};

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

@@ -0,0 +1,151 @@
+import type {IsNever} from './is-never.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {And} from './and.d.ts';
+import type {Or} from './or.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {OrAll} from './or-all.d.ts';
+
+export type ExtendsStrictOptions = {
+	/**
+	Whether to distribute over unions.
+
+	@default false
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<string | number, string, {distributiveUnions: true}>;
+	//=> boolean
+
+	type T2 = ExtendsStrict<string | number, string, {distributiveUnions: false}>;
+	//=> false
+	```
+	*/
+	distributiveUnions?: boolean;
+
+	/**
+	Whether `never` extends every other type.
+
+	When enabled, `never` is not treated as a bottom type and only extends itself (or `any` / `unknown`).
+
+	@default true
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<never, number, {strictNever: true}>;
+	//=> false
+
+	type T2 = ExtendsStrict<never, number, {strictNever: false}>;
+	//=> true
+
+	type T3 = ExtendsStrict<never, never, {strictNever: true}>;
+	//=> true
+
+	type T4 = ExtendsStrict<never, any, {strictNever: true}>;
+	//=> true
+
+	type T5 = ExtendsStrict<never, unknown, {strictNever: true}>;
+	//=> true
+	```
+
+	Note: This option only has an effect when checking assignability from `never` (`ExtendsStrict<never, ...>`), and not when checking assignability to `never` (`ExtendsStrict<..., never>`).
+	*/
+	strictNever?: boolean;
+
+	/**
+	Whether `any` extends every other type.
+
+	When enabled, `any` does not extend every other type, it only extends itself (or `unknown`).
+
+	@default false
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<any, number, {strictAny: true}>;
+	//=> false
+
+	type T2 = ExtendsStrict<any, number, {strictAny: false; distributiveUnions: false}>;
+	//=> true
+
+	type T3 = ExtendsStrict<any, any, {strictAny: true}>;
+	//=> true
+
+	type T4 = ExtendsStrict<any, unknown, {strictAny: true}>;
+	//=> true
+	```
+
+	Note: If `strictAny` is `false` and `distributiveUnions` is `true`, then `any` would distribute and the result would be the `boolean` type, except when checking assignability to `any` or `unknown`.
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<any, number, {strictAny: false; distributiveUnions: true}>;
+	//=> boolean
+
+	type T2 = ExtendsStrict<any, any, {strictAny: false; distributiveUnions: true}>;
+	//=> true
+
+	type T3 = ExtendsStrict<any, unknown, {strictAny: false; distributiveUnions: true}>;
+	//=> true
+	```
+
+	Note: This option only has an effect when checking assignability from `any` (`ExtendsStrict<any, ...>`), and not when checking assignability to `any` (`ExtendsStrict<..., any>`).
+	*/
+	strictAny?: boolean;
+};
+
+type DefaultExtendsStrictOptions = {
+	distributiveUnions: false;
+	strictNever: true;
+	strictAny: false;
+};
+
+/**
+A customizable version of `extends` for checking whether one type is assignable to another.
+
+Refer {@link ExtendsStrictOptions} for the different ways you can customize the behavior of this type.
+
+@example
+```
+import type {ExtendsStrict} from 'type-fest';
+
+type T1 = ExtendsStrict<number | string, string, {distributiveUnions: false}>;
+//=> false
+
+type T2 = ExtendsStrict<never, number, {strictNever: true}>;
+//=> false
+
+type T3 = ExtendsStrict<any, number, {strictAny: true}>;
+//=> false
+```
+
+@see {@link ExtendsStrictOptions}
+
+@category Improved Built-in
+*/
+export type ExtendsStrict<Left, Right, Options extends ExtendsStrictOptions = {}> =
+	_ExtendsStrict<Left, Right, ApplyDefaultOptions<ExtendsStrictOptions, DefaultExtendsStrictOptions, Options>>;
+
+type _ExtendsStrict<Left, Right, Options extends Required<ExtendsStrictOptions>> =
+	And<IsAny<Left>, Options['strictAny']> extends true
+		? Or<IsAny<Right>, IsUnknown<Right>>
+		: IsNever<Left> extends true
+			? Options['strictNever'] extends true
+				? OrAll<[IsNever<Right>, IsAny<Right>, IsUnknown<Right>]>
+				: true
+			: Options['distributiveUnions'] extends true
+				? Left extends Right
+					? true
+					: false
+				: [Left] extends [Right]
+					? true
+					: false;
+
+export {};

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

@@ -0,0 +1,56 @@
+import type {IsAny} from './is-any.d.ts';
+import type {If} from './if.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+A stricter version of `Extract<T, U>` that extracts types only when they are exactly identical.
+
+@example
+```
+import type {ExtractExactly} from 'type-fest';
+
+type TestExtract1 = Extract<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c'
+
+type TestExtractExactly1 = ExtractExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> never
+
+type TestExtract2 = Extract<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExtractExactly2 = ExtractExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExtract3 = Extract<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string} | {a: string; b: string}
+
+type TestExtractExactly3 = ExtractExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string}
+```
+
+@category Improved Built-in
+*/
+export type ExtractExactly<Union, Match> =
+	IfNotAnyOrNever<Union, {
+		ifNot: _ExtractExactly<Union, Match>;
+		// If `Union` is `any`, then if `Match` is `any`, return `any`, else return `never`.
+		ifAny: If<IsAny<Match>, Union, never>;
+		// If `Union` is `never`, return `never`, doesn't matter what `Match` is.
+		ifNever: never;
+	}>;
+
+type _ExtractExactly<Union, Match> =
+	IfNotAnyOrNever<Match, {
+		ifNot: Union extends unknown // For distributing `Union`
+			? [Match extends unknown // For distributing `Match`
+				? If<IsEqual<Union, Match>, true, never>
+				: never] extends [never] ? never : Union
+			: never;
+		// If `Match` is `any` or `never`, then return `never`,
+		// because `Union` cannot be `any` or `never` here.
+		ifAny: never;
+		ifNever: never;
+	}>;
+
+export {};

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

@@ -0,0 +1,30 @@
+import type {SplitOnRestElement} from './split-on-rest-element.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extract the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element type from an array.
+
+@example
+```
+import type {ExtractRestElement} from 'type-fest';
+
+type T1 = ExtractRestElement<[number, ...string[], string, 'foo']>;
+//=> string
+
+type T2 = ExtractRestElement<[...boolean[], string]>;
+//=> boolean
+
+type T3 = ExtractRestElement<[...Array<'foo'>, true]>;
+//=> 'foo'
+
+type T4 = ExtractRestElement<[number, string]>;
+//=> never
+```
+
+@see {@link ExcludeRestElement}
+@see {@link SplitOnRestElement}
+@category Array
+*/
+export type ExtractRestElement<T extends UnknownArray> = SplitOnRestElement<T>[1][number];
+
+export {};