@envive-ai/react-hooks 0.2.6-alpha-arthur-1 → 0.2.6-alpha.11

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

@@ -0,0 +1,87 @@
+// 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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,121 @@
+// 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

@@ -0,0 +1,98 @@
+// 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

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

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

@@ -0,0 +1,93 @@
+// 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

@@ -0,0 +1,8 @@
+// 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

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,76 @@
+// 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

@@ -0,0 +1,28 @@
+// 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

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