@envive-ai/react-hooks 0.1.0

package/src/application/models/supportedOrgs.ts

@@ -0,0 +1,137 @@
+import { OrgShortName } from 'src/application/models/orgsEnum';
+import { ColorMapping, OrgPageConfig, OrgUIConfig } from 'src/contexts/types';
+
+export { OrgShortName } from './orgsEnum';
+
+export type BasicOrgInfoType = {
+  shortName: string;
+  name: string;
+  domain: string;
+  defaultProductId: string;
+  alwaysEnabledMerchants: boolean;
+  orgUIConfig: () => OrgUIConfig | undefined;
+  orgPageConfig: () => OrgPageConfig;
+  orgColors: () => ColorMapping | {};
+};
+
+export const getOrgInfo = async (orgShortName: string): Promise<BasicOrgInfoType> => {
+  switch (orgShortName) {
+    case OrgShortName.Bandolier:
+      return import('src/merchants/bandolier/bandolier').then((module) => module.bandolierOrgInfo);
+    case OrgShortName.Carpe:
+      return import('src/merchants/carpe/carpe').then((module) => module.carpeOrgInfo);
+    case OrgShortName.Coterie:
+      return import('src/merchants/coterie/coterie').then((module) => module.coterieOrgInfo);
+    case OrgShortName.DreamlandBaby:
+      return import('src/merchants/dreamlandBaby/dreamlandBaby').then(
+        (module) => module.dreamlandBabyOrgInfo,
+      );
+    case OrgShortName.ForLoveAndLemons:
+      return import('src/merchants/forLoveAndLemons/forLoveAndLemons').then(
+        (module) => module.forLoveAndLemonsOrgInfo,
+      );
+    case OrgShortName.Greenpan:
+      return import('src/merchants/greenpan/greenpan').then((module) => module.greenpanOrgInfo);
+    case OrgShortName.GrooveLife:
+      return import('src/merchants/grooveLife/grooveLife').then(
+        (module) => module.grooveLifeOrgInfo,
+      );
+    case OrgShortName.JackArcher:
+      return import('src/merchants/jackArcher/jackArcher').then(
+        (module) => module.jackArcherOrgInfo,
+      );
+    case OrgShortName.JordanCraig:
+      return import('src/merchants/jordanCraig/jordanCraig').then(
+        (module) => module.jordanCraigOrgInfo,
+      );
+    case OrgShortName.KutFromTheKloth:
+      return import('src/merchants/kutFromTheKloth/kutFromTheKloth').then(
+        (module) => module.kutFromTheKlothOrgInfo,
+      );
+    case OrgShortName.LarryAndSerges:
+      return import('src/merchants/larryAndSerges/larryAndSerges').then(
+        (module) => module.larryAndSergesOrgInfo,
+      );
+    case OrgShortName.LeapsAndRebounds:
+      return import('src/merchants/leapsAndRebounds/leapsAndRebounds').then(
+        (module) => module.leapsAndReboundsOrgInfo,
+      );
+    case OrgShortName.MantraBrand:
+      return import('src/merchants/mantraBrand/mantraBrand').then(
+        (module) => module.mantraBrandOrgInfo,
+      );
+
+    // ---- SPANX ----
+    case OrgShortName.Spanx:
+      return import('src/merchants/spanx/spanx').then((module) => module.spanxOrgInfo);
+    // Spanx staging (headless shopify)
+    case OrgShortName.SpanxStaging:
+      return import('src/merchants/spanx/spanxStaging').then((module) => module.spanxOrgInfo);
+    // ---------------
+
+    case OrgShortName.Supergoop:
+      return import('src/merchants/supergoop/supergoop').then((module) => module.supergoopOrgInfo);
+    case OrgShortName.UniqueVintage:
+      return import('src/merchants/uniqueVintage/uniqueVintage').then(
+        (module) => module.uniqueVintageOrgInfo,
+      );
+    case OrgShortName.WestonJonBoucher:
+      return import('src/merchants/westonJonBoucher/westonJonBoucher').then(
+        (module) => module.westonJonBoucherOrgInfo,
+      );
+    case OrgShortName.WolfMattress:
+      return import('src/merchants/wolfMattress/wolfMattress').then(
+        (module) => module.wolfMattressOrgInfo,
+      );
+    case OrgShortName.WolfTactical:
+      return import('src/merchants/wolfTactical/wolfTactical').then(
+        (module) => module.wolfTacticalOrgInfo,
+      );
+    /* -- Below items are generated by plop -- */
+  case OrgShortName.SkinPerfection:
+    return import('src/merchants/skinPerfection/skinPerfection').then(
+      (module) => module.skinPerfectionOrgInfo,
+    );
+  case OrgShortName.LookOptic:
+    return import('src/merchants/lookOptic/lookOptic').then(
+      (module) => module.lookOpticOrgInfo,
+    );  
+  case OrgShortName.FiveCbd:
+    return import('src/merchants/fiveCbd/fiveCbd').then(
+      (module) => module.fiveCbdOrgInfo,
+    );
+    case OrgShortName.SnapSupplements:
+      return import('src/merchants/snapSupplements/snapSupplements').then(
+        (module) => module.snapSupplementsOrgInfo,
+      );
+    case OrgShortName.Longevityrx:
+      return import('src/merchants/longevityrx/longevityrx').then(
+        (module) => module.longevityrxOrgInfo,
+      );
+    case OrgShortName.VenaCbd:
+      return import('src/merchants/venaCbd/venaCbd').then((module) => module.venaCbdOrgInfo);
+    case OrgShortName.Medterra:
+      return import('src/merchants/medterra/medterra').then((module) => module.medterraOrgInfo);
+
+    case OrgShortName.Modells:
+      return import('src/merchants/modells/modells').then((module) => module.modellsOrgInfo);
+    case OrgShortName.PressedFloral:
+      return import('src/merchants/pressedFloral/pressedFloral').then(
+        (module) => module.pressedFloralOrgInfo,
+      );
+    case OrgShortName.KindredBravely:
+      return import('src/merchants/kindredBravely/kindredBravely').then(
+        (module) => module.kindredBravelyOrgInfo,
+      );
+    case OrgShortName.WineEnthusiast:
+      return import('src/merchants/wineEnthusiast/wineEnthusiast').then(
+        (module) => module.wineEnthusiastOrgInfo,
+      );
+    case OrgShortName.HomegrownCannabis:
+      return import('src/merchants/homegrownCannabis/homegrownCannabis').then(
+        (module) => module.homegrownCannabisOrgInfo,
+      );
+    default:
+      return import('src/merchants/default').then((module) => module.defaultOrgInfo);
+  }
+};

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, '_'>;