@envive-ai/react-hooks 0.2.5 → 0.2.6-alpha

package/src/application/models/utilityTypes/camelCase.ts

@@ -1,87 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/camel-case.d.ts
-
-import { SplitWords } from './splitWords';
-
-/**
- * CamelCase options.
- *
- * @see {@link CamelCase}
- */
-export type CamelCaseOptions = {
-  /**
-   * Whether to preserved consecutive uppercase letter.
-   *
-   * @default true
-   */
-  preserveConsecutiveUppercase?: boolean;
-};
-
-/**
- * Convert an array of words to camel-case.
- */
-type CamelCaseFromArray<
-  Words extends string[],
-  Options extends CamelCaseOptions,
-  OutputString extends string = '',
-> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]]
-  ? Options['preserveConsecutiveUppercase'] extends true
-    ? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
-    : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
-  : OutputString;
-
-/**
- * Convert a string literal to camel-case.
- *
- * This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
- *
- * By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
- *
- * @example
- * ```
- * import type {CamelCase} from 'type-fest';
- *
- * // Simple
- *
- * const someVariable: CamelCase<'foo-bar'> = 'fooBar';
- *
- * // Advanced
- *
- * type CamelCasedProperties<T> = {
- * 	[K in keyof T as CamelCase<K>]: T[K]
- * };
- *
- * interface RawOptions {
- * 	'dry-run': boolean;
- * 	'full_family_name': string;
- * 	foo: number;
- * 	BAR: string;
- * 	QUZ_QUX: number;
- * 	'OTHER-FIELD': boolean;
- * }
- *
- * const dbResult: CamelCasedProperties<RawOptions> = {
- * 	dryRun: true,
- * 	fullFamilyName: 'bar.js',
- * 	foo: 123,
- * 	bar: 'foo',
- * 	quzQux: 6,
- * 	otherField: false
- * };
- * ```
- *
- * @category Change case
- * @category Template literal
- */
-export type CamelCase<
-  Type,
-  Options extends CamelCaseOptions = { preserveConsecutiveUppercase: true },
-> = Type extends string
-  ? string extends Type
-    ? Type
-    : Uncapitalize<
-        CamelCaseFromArray<
-          SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
-          Options
-        >
-      >
-  : Type;

package/src/application/models/utilityTypes/camelCasedPropertiesDeep.ts

@@ -1,80 +0,0 @@
-import { CamelCase, CamelCaseOptions } from './camelCase';
-import { UnknownArray } from './unknownArray';
-
-/**
- * Convert object properties to camel case recursively.
- *
- * This can be useful when, for example, converting some API types from a different style.
- *
- * @see CamelCasedProperties
- * @see CamelCase
- *
- * @example
- * ```
- * import type {CamelCasedPropertiesDeep} from 'type-fest';
- *
- * interface User {
- * 	UserId: number;
- * 	UserName: string;
- * }
- *
- * interface UserWithFriends {
- * 	UserInfo: User;
- * 	UserFriends: User[];
- * }
- *
- * const result: CamelCasedPropertiesDeep<UserWithFriends> = {
- * 	userInfo: {
- * 		userId: 1,
- * 		userName: 'Tom',
- * 	},
- * 	userFriends: [
- * 		{
- * 			userId: 2,
- * 			userName: 'Jerry',
- * 		},
- * 		{
- * 			userId: 3,
- * 			userName: 'Spike',
- * 		},
- * 	],
- * };
- * ```
- *
- * @category Change case
- * @category Template literal
- * @category Object
- */
-export type CamelCasedPropertiesDeep<
-  Value,
-  Options extends CamelCaseOptions = { preserveConsecutiveUppercase: true },
-> = Value extends Function
-  ? Value
-  : Value extends UnknownArray
-    ? CamelCasedPropertiesArrayDeep<Value>
-    : Value extends Set<infer U>
-      ? Set<CamelCasedPropertiesDeep<U, Options>>
-      : {
-          [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options>;
-        };
-
-// This is a copy of DelimiterCasedPropertiesArrayDeep (see: delimiter-cased-properties-deep.d.ts).
-// These types should be kept in sync.
-type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends []
-  ? []
-  : // Tailing spread array
-    Value extends [infer U, ...infer V]
-    ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>]
-    : Value extends readonly [infer U, ...infer V]
-      ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>]
-      : // Leading spread array
-        Value extends readonly [...infer U, infer V]
-        ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>]
-        : Value extends readonly [...infer U, infer V]
-          ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>]
-          : // Array
-            Value extends Array<infer U>
-            ? Array<CamelCasedPropertiesDeep<U>>
-            : Value extends ReadonlyArray<infer U>
-              ? ReadonlyArray<CamelCasedPropertiesDeep<U>>
-              : never;

package/src/application/models/utilityTypes/delimiterCase.ts

@@ -1,121 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/delimiter-case.d.ts
-
-import type { UpperCaseCharacters, WordSeparators } from './internal';
-
-// Transforms a string that is fully uppercase into a fully lowercase version. Needed to add support for SCREAMING_SNAKE_CASE, see https://github.com/sindresorhus/type-fest/issues/385
-type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
-
-// This implementation does not support SCREAMING_SNAKE_CASE, it is used internally by `SplitIncludingDelimiters`.
-type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends ''
-  ? []
-  : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}`
-    ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
-      ? UsedDelimiter extends Delimiter
-        ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
-          ? [
-              ...SplitIncludingDelimiters<FirstPart, Delimiter>,
-              UsedDelimiter,
-              ...SplitIncludingDelimiters<SecondPart, Delimiter>,
-            ]
-          : never
-        : never
-      : never
-    : [Source];
-
-/**
- * Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
- *
- * @category Template literal
- */
-export type SplitIncludingDelimiters<
-  Source extends string,
-  Delimiter extends string,
-> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
-
-/**
- *Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
- *
- *@see StringArrayToDelimiterCase
- */
-type StringPartToDelimiterCase<
-  StringPart extends string,
-  Start extends boolean,
-  UsedWordSeparators extends string,
-  UsedUpperCaseCharacters extends string,
-  Delimiter extends string,
-> = StringPart extends UsedWordSeparators
-  ? Delimiter
-  : Start extends true
-    ? Lowercase<StringPart>
-    : StringPart extends UsedUpperCaseCharacters
-      ? `${Delimiter}${Lowercase<StringPart>}`
-      : StringPart;
-
-/**
- * Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
- *
- * It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
- *
- * @see SplitIncludingDelimiters
- */
-type StringArrayToDelimiterCase<
-  Parts extends readonly any[],
-  Start extends boolean,
-  UsedWordSeparators extends string,
-  UsedUpperCaseCharacters extends string,
-  Delimiter extends string,
-> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-  ? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
-  : Parts extends [string]
-    ? string
-    : '';
-
-/**
- * Convert a string literal to a custom string delimiter casing.
- *
- * This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
- *
- * @see KebabCase
- * @see SnakeCase
- *
- * @example
- * ```
- * import type {DelimiterCase} from 'type-fest';
- *
- * // Simple
- *
- * const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
- *
- * // Advanced
- *
- * type OddlyCasedProperties<T> = {
- * 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
- * };
- *
- * interface SomeOptions {
- * 	dryRun: boolean;
- * 	includeFile: string;
- * 	foo: number;
- * }
- *
- * const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
- * 	'dry#run': true,
- * 	'include#file': 'bar.js',
- * 	foo: 123
- * };
- * ```
- *
- * @category Change case
- * @category Template literal
- */
-export type DelimiterCase<Value, Delimiter extends string> = string extends Value
-  ? Value
-  : Value extends string
-    ? StringArrayToDelimiterCase<
-        SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
-        true,
-        WordSeparators,
-        UpperCaseCharacters,
-        Delimiter
-      >
-    : Value;

package/src/application/models/utilityTypes/delimiterCasedPropertiesDeep.ts

@@ -1,98 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/delimiter-cased-properties-deep.d.ts
-
-import type { DelimiterCase } from './delimiterCase';
-import type { NonRecursiveType } from './internal';
-import type { UnknownArray } from './unknownArray';
-
-/**
- * Convert object properties to delimiter case recursively.
- *
- * This can be useful when, for example, converting some API types from a different style.
- *
- * @see DelimiterCase
- * @see DelimiterCasedProperties
- *
- * @example
- * ```
- * import type {DelimiterCasedPropertiesDeep} from 'type-fest';
- *
- * interface User {
- * 	userId: number;
- * 	userName: string;
- * }
- *
- * interface UserWithFriends {
- * 	userInfo: User;
- * 	userFriends: User[];
- * }
- *
- * const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
- * 	'user-info': {
- * 	'user-id': 1,
- * 		'user-name': 'Tom',
- * 	},
- * 	'user-friends': [
- * 		{
- * 			'user-id': 2,
- * 			'user-name': 'Jerry',
- * 		},
- * 		{
- * 			'user-id': 3,
- * 			'user-name': 'Spike',
- * 		},
- * 	],
- * };
- * ```
- *
- * @category Change case
- * @category Template literal
- * @category Object
- */
-export type DelimiterCasedPropertiesDeep<
-  Value,
-  Delimiter extends string,
-> = Value extends NonRecursiveType
-  ? Value
-  : Value extends UnknownArray
-    ? DelimiterCasedPropertiesArrayDeep<Value, Delimiter>
-    : Value extends Set<infer U>
-      ? Set<DelimiterCasedPropertiesDeep<U, Delimiter>>
-      : {
-          [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<
-            Value[K],
-            Delimiter
-          >;
-        };
-
-// This is a copy of CamelCasedPropertiesArrayDeep (see: camel-cased-properties-deep.d.ts).
-// These types should be kept in sync.
-type DelimiterCasedPropertiesArrayDeep<
-  Value extends UnknownArray,
-  Delimiter extends string,
-> = Value extends []
-  ? []
-  : // Tailing spread array
-    Value extends [infer U, ...infer V]
-    ? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
-    : Value extends readonly [infer U, ...infer V]
-      ? readonly [
-          DelimiterCasedPropertiesDeep<U, Delimiter>,
-          ...DelimiterCasedPropertiesDeep<V, Delimiter>,
-        ]
-      : // Leading spread array
-        Value extends readonly [...infer U, infer V]
-        ? [
-            ...DelimiterCasedPropertiesDeep<U, Delimiter>,
-            DelimiterCasedPropertiesDeep<V, Delimiter>,
-          ]
-        : Value extends readonly [...infer U, infer V]
-          ? readonly [
-              ...DelimiterCasedPropertiesDeep<U, Delimiter>,
-              DelimiterCasedPropertiesDeep<V, Delimiter>,
-            ]
-          : // Array
-            Value extends Array<infer U>
-            ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
-            : Value extends ReadonlyArray<infer U>
-              ? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>>
-              : never;

package/src/application/models/utilityTypes/index.ts

@@ -1 +0,0 @@
-export * from './camelCasedPropertiesDeep';

package/src/application/models/utilityTypes/internal.ts

@@ -1,93 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/internal.d.ts
-
-import { Primitive } from './primitive';
-import { Trim } from './trim';
-
-/**
- * Matches any primitive, `void`, `Date`, or `RegExp` value.
- */
-export type BuiltIns = Primitive | void | Date | RegExp;
-
-/**
- * Matches non-recursive types.
- */
-export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-
-/**
- * Returns a boolean for whether the string is numeric.
- *
- * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
- */
-export type IsNumeric<T extends string> = T extends `${number}`
-  ? Trim<T> extends T
-    ? true
-    : false
-  : false;
-
-/**
- * Returns a boolean for whether the string is lowercased.
- */
-export type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
-
-/**
- * Returns a boolean for whether the string is upper-cased.
- */
-export type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
-
-export type WordSeparators = '-' | '_' | Whitespace;
-
-export type Whitespace =
-  | '\u{9}' // '\t'
-  | '\u{A}' // '\n'
-  | '\u{B}' // '\v'
-  | '\u{C}' // '\f'
-  | '\u{D}' // '\r'
-  | '\u{20}' // ' '
-  | '\u{85}'
-  | '\u{A0}'
-  | '\u{1680}'
-  | '\u{2000}'
-  | '\u{2001}'
-  | '\u{2002}'
-  | '\u{2003}'
-  | '\u{2004}'
-  | '\u{2005}'
-  | '\u{2006}'
-  | '\u{2007}'
-  | '\u{2008}'
-  | '\u{2009}'
-  | '\u{200A}'
-  | '\u{2028}'
-  | '\u{2029}'
-  | '\u{202F}'
-  | '\u{205F}'
-  | '\u{3000}'
-  | '\u{FEFF}';
-
-export type UpperCaseCharacters =
-  | 'A'
-  | 'B'
-  | 'C'
-  | 'D'
-  | 'E'
-  | 'F'
-  | 'G'
-  | 'H'
-  | 'I'
-  | 'J'
-  | 'K'
-  | 'L'
-  | 'M'
-  | 'N'
-  | 'O'
-  | 'P'
-  | 'Q'
-  | 'R'
-  | 'S'
-  | 'T'
-  | 'U'
-  | 'V'
-  | 'W'
-  | 'X'
-  | 'Y'
-  | 'Z';

package/src/application/models/utilityTypes/primitive.ts

@@ -1,8 +0,0 @@
-// this type comes from https://github.com/sindresorhus/type-fest/blob/main/source/primitive.d.ts
-
-/**
- * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
- *
- * @category Type
- */
-export type Primitive = null | undefined | string | number | boolean | symbol | bigint;

package/src/application/models/utilityTypes/snakeCasedPropertiesDeep.ts

@@ -1,49 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/snake-cased-properties-deep.d.ts
-
-import type { DelimiterCasedPropertiesDeep } from './delimiterCasedPropertiesDeep';
-
-/**
- * Convert object properties to snake case recursively.
- *
- * This can be useful when, for example, converting some API types from a different style.
- *
- * @see SnakeCase
- * @see SnakeCasedProperties
- *
- * @example
- * ```
- * import type {SnakeCasedPropertiesDeep} from 'type-fest';
- *
- * interface User {
- * 	userId: number;
- * 	userName: string;
- * }
- *
- * interface 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',
- * 		},
- * 	],
- * };
- * ```
- *
- * @category Change case
- * @category Template literal
- * @category Object
- */
-export type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;

package/src/application/models/utilityTypes/splitWords.ts

@@ -1,76 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/split-words.d.ts
-
-import type { IsLowerCase, IsNumeric, IsUpperCase, WordSeparators } from './internal';
-
-type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
-
-type RemoveLastCharacter<
-  Sentence extends string,
-  Character extends string,
-> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;
-
-/**
- * Split a string (almost) like Lodash's `_.words()` function.
- *
- * - Split on each word that begins with a capital letter.
- * - Split on each {@link WordSeparators}.
- * - Split on numeric sequence.
- *
- * @example
- * ```
- * type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']
- * type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']
- * type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']
- * type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']
- * type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']
- * ```
- *
- * @internal
- * @category Change case
- * @category Template literal
- */
-export type SplitWords<
-  Sentence extends string,
-  LastCharacter extends string = '',
-  CurrentWord extends string = '',
-> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
-  ? FirstCharacter extends WordSeparators
-    ? // Skip word separator
-      [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters>]
-    : LastCharacter extends ''
-      ? // Fist char of word
-        SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>
-      : // Case change: non-numeric to numeric, push word
-        [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-        ? [
-            ...SkipEmptyWord<CurrentWord>,
-            ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>,
-          ]
-        : // Case change: numeric to non-numeric, push word
-          [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-          ? [
-              ...SkipEmptyWord<CurrentWord>,
-              ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>,
-            ]
-          : // No case change: concat word
-            [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-            ? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-            : // Case change: lower to upper, push word
-              [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>]
-              ? [
-                  ...SkipEmptyWord<CurrentWord>,
-                  ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>,
-                ]
-              : // Case change: upper to lower, brings back the last character, push word
-                [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>]
-                ? [
-                    ...RemoveLastCharacter<CurrentWord, LastCharacter>,
-                    ...SplitWords<
-                      RemainingCharacters,
-                      FirstCharacter,
-                      `${LastCharacter}${FirstCharacter}`
-                    >,
-                  ]
-                : // No case change: concat word
-                  SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
-  : [...SkipEmptyWord<CurrentWord>];

package/src/application/models/utilityTypes/trim.ts

@@ -1,28 +0,0 @@
-// these types come from https://github.com/sindresorhus/type-fest/blob/main/source/trim.d.ts
-
-import type { Whitespace } from './internal';
-
-/**
- * Remove spaces from the left side.
- */
-type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
-
-/**
- * Remove spaces from the right side.
- */
-type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
-
-/**
- * Remove leading and trailing spaces from a string.
- * @example
- * ```
- * import type {Trim} from 'type-fest';
- *
- * Trim<' foo '>
- * //=> 'foo'
- * ```
- *
- * @category String
- * @category Template literal
- */
-export type Trim<V extends string> = TrimLeft<TrimRight<V>>;

package/src/application/models/utilityTypes/unknownArray.ts

@@ -1,25 +0,0 @@
-/**
- * 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[];

package/src/application/models/variantInfo/index.ts

@@ -1 +0,0 @@
-export * from './variantInfo';

package/src/application/models/variantInfo/pageVisitInfo.ts

@@ -1,6 +0,0 @@
-import { PageVisitCategory } from '@spiffy-ai/commerce-api-client';
-
-export interface PageVisitInfo {
-  url: string;
-  pageVisitCategory: PageVisitCategory;
-}

package/src/application/models/variantInfo/plpInfo.ts

@@ -1,3 +0,0 @@
-export interface PLPInfo {
-  plpId: string;
-}