danholibraryjs 1.10.0 → 2.0.0

package/src/Extensions/Map.ts

@@ -1,88 +1,88 @@
 declare global {
-    interface Map<K, V> {
-        /**
-         * Converts into Array<[Key, Value]>
-         */
-        array(): Array<[K, V]>
-        /**
-         * Maps values into new types of generics
-         * @param callback Callbacking function to map values
-         */
-        map<EK, EV>(callback: (value: V, key: K, index: number, self: this) => [EK, EV]): Map<EK, EV>
-        /**
-         * Returns array of "accepted" values. Criteria defined in callback param
-         * @param callback Callbacking function to filter away unwanted values
-         */
-        filter(callback: (value: V, key: K, index: number, self: this) => boolean): Map<K, V>
-        /**
-         * Returns array of keys
-         */
-        keyArr(): Array<K>
-        /**
-         * Returns array of values
-         */
-        valueArr(): Array<V>
-        /**
-         * Returns first [key, value] match to callback param. Returns undefined if nothing found
-         * @param callback Callbacking function to find KeyValuePair
-         */
-        find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined
-        /**
-         * Whether or not map includes a  value. Returns true if it does, false if not ¯\_(ツ)_/¯ 
-         * @param value Value that may be includded in map
-         * @param fromIndex Start looking for value from specific index+. Default: 0
-         */
-        includes(value: V, fromIndex?: number): boolean
-    }
+  interface Map<K, V> {
+    /**
+     * Converts into Array<[Key, Value]>
+     */
+    array(): Array<[K, V]>;
+    /**
+     * Maps values into new types of generics
+     * @param callback Callbacking function to map values
+     */
+    map<EK, EV>(callback: (value: V, key: K, index: number, self: this) => [EK, EV]): Map<EK, EV>;
+    /**
+     * Returns array of "accepted" values. Criteria defined in callback param
+     * @param callback Callbacking function to filter away unwanted values
+     */
+    filter(callback: (value: V, key: K, index: number, self: this) => boolean): Map<K, V>;
+    /**
+     * Returns array of keys
+     */
+    keyArr(): Array<K>;
+    /**
+     * Returns array of values
+     */
+    valueArr(): Array<V>;
+    /**
+     * Returns first [key, value] match to callback param. Returns undefined if nothing found
+     * @param callback Callbacking function to find KeyValuePair
+     */
+    find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
+    /**
+     * Whether or not map includes a  value. Returns true if it does, false if not ¯\_(ツ)_/¯ 
+     * @param value Value that may be includded in map
+     * @param fromIndex Start looking for value from specific index+. Default: 0
+     */
+    includes(value: V, fromIndex?: number): boolean;
+  }
 }
 
 function array<K, V>(this: Map<K, V>): Array<[K, V]> {
-    let result = new Array<[K, V]>();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
+  let result = new Array<[K, V]>();
+  for (const kvp of this) {
+    result.push(kvp);
+  }
+  return result;
 }
 Map.prototype.array = array;
 
 function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV> {
-    return this.array()
-        .map(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<EK, EV>())
+  return this.array()
+    .map(([k, v], i) => callback(v, k, i, this))
+    .reduce((map, [key, value]) =>
+      map.set(key, value),
+      new Map<EK, EV>());
 }
 Map.prototype.map = map;
 
 function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V> {
-    return this.array()
-        .filter(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<K, V>())
+  return this.array()
+    .filter(([k, v], i) => callback(v, k, i, this))
+    .reduce((map, [key, value]) =>
+      map.set(key, value),
+      new Map<K, V>());
 }
 Map.prototype.filter = filter;
 
 function keyArr<K, V>(this: Map<K, V>): Array<K> {
-    return this.array().map(([k]) => k);
+  return this.array().map(([k]) => k);
 }
 Map.prototype.keyArr = keyArr;
 
 function valueArr<K, V>(this: Map<K, V>): Array<V> {
-    return this.array().map(([_, v]) => v);
+  return this.array().map(([_, v]) => v);
 }
 Map.prototype.valueArr = valueArr;
 
 function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
+  return this.array().find(([k, v], i) => callback(v, k, i, this));
 }
 Map.prototype.find = find;
 
 function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
-    return this.valueArr().includes(item, fromIndex);
+  return this.valueArr().includes(item, fromIndex);
 }
 Map.prototype.includes = includes;
 
 export const MapExtensions = {
-    array, map, filter, keyArr, valueArr, find, includes
-}
+  array, map, filter, keyArr, valueArr, find, includes
+};

package/src/Extensions/Number.ts

@@ -0,0 +1,50 @@
+type Separators = {
+  thousand: string;
+  decimal: string;
+}
+
+declare global {
+  interface Number {
+    toSeparationString(separators: Partial<Separators>): string;
+    toRomanNumeral(): string;
+  }
+}
+
+export function toSeparationString(this: number, separators: Partial<Separators>): string {
+  const { thousand = '.', decimal = '.' } = separators;
+  const [integerPart, decimalPart] = this.toString().split('.');
+  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousand);
+  return decimalPart ? `${formattedInteger}${decimal}${decimalPart}` : formattedInteger;
+}
+Number.prototype.toSeparationString = toSeparationString;
+
+export function toRomanNumeral(this: number): string {
+  if (this <= 0 || this >= 4000) throw new RangeError('Number must be between 1 and 3999 to convert to Roman numeral');
+
+  const numeralMap: [number, string][] = [
+    [1000, 'M'], 
+    [900, 'CM'], 
+    [500, 'D'], 
+    [400, 'CD'],
+    [100, 'C'], 
+    [90, 'XC'], 
+    [50, 'L'], 
+    [40, 'XL'],
+    [10, 'X'], 
+    [9, 'IX'], 
+    [5, 'V'], 
+    [4, 'IV'],
+    [1, 'I']
+  ];
+
+  let value = this;
+  return numeralMap.reduce((acc, [numeralValue, numeral]) => {
+    while (value >= numeralValue) {
+      acc += numeral;
+      value -= numeralValue;
+    }
+
+    return acc;
+  }, '');
+}
+Number.prototype.toRomanNumeral = toRomanNumeral;

package/src/Extensions/Object/arrays.extension.ts

@@ -0,0 +1,27 @@
+import { ValueOf } from "../../Types";
+
+declare global {
+  interface ObjectConstructor {
+    /**
+     * Destructures object into array of [property, value]
+     * @param from Object to destruct
+     */
+    array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+
+    /**
+     * Destructures object into array of property keys
+     * @param from Object to destruct
+     */
+    keysOf<From extends {} = {}>(from: From): Array<keyof From>;
+  }
+}
+
+export function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
+  return Object.entries(from) as Array<[keyof From, ValueOf<From>]>;
+}
+Object.array = array;
+
+export function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From> {
+  return Object.keys(from) as Array<keyof From>;
+}
+Object.keysOf = keysOf;

package/src/Extensions/Object/booleans.extension.ts

@@ -0,0 +1,46 @@
+declare global {
+  interface ObjectConstructor {
+    /**
+     * Returns true if objects are equal by comparing their properties and values recursively. Does not compare functions.
+     * @param a First object
+     * @param b Second object
+     * @returns true if objects are equal, false otherwise
+     */
+    areEqual<T extends object | null>(a?: T, b?: T): boolean;
+
+    /**
+     * Returns true if object is empty
+     * @param obj Object to check
+     */
+    isNullOrUndefined(obj: any): obj is null | undefined;
+  }
+}
+
+export function areEqual<T extends object | null>(a?: T, b?: T): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (isNullOrUndefined(a) && isNullOrUndefined(b)) return true;
+
+  const keysA = Object.keys(a ?? {});
+  const keysB = Object.keys(b ?? {});
+  if (keysA.length !== keysB.length) return false;
+
+  try {
+    const jsonA = JSON.stringify(a);
+    const jsonB = JSON.stringify(b);
+    if (jsonA === jsonB) return true;
+  } catch {
+    for (const key of keysA) {
+      if (!keysB.includes(key)) return false;
+      if (!areEqual((a as any)[key], (b as any)[key])) return false;
+    }
+  }
+
+  return true;
+}
+Object.areEqual = areEqual;
+
+export function isNullOrUndefined(obj: any): obj is null | undefined {
+  return obj === null || obj === undefined;
+}
+Object.isNullOrUndefined = isNullOrUndefined;

package/src/Extensions/Object/extracts.extension.ts

@@ -0,0 +1,102 @@
+declare global {
+  interface ObjectConstructor {
+    /**
+     * Get a copy of object without specified properties or partial versions.
+     * @param from Object to extract properties from
+     * @param props Properties to extract/Omit
+     */
+    omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+
+    /**
+     * Get a copy of object with only specified properties or partial versions.
+     * @param from Object to extract properties from
+     * @param props Properties to extract/Pick
+     */
+    pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+
+    /**
+     * Receive an object with properties that are not in union of source and target objects
+     * @param source Source object 
+     * @param target Target object 
+     * @param exclude Properties to exclude from difference
+     * @returns Object with properties that are not in union of source and target objects, excluding specified properties
+     */
+    difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+
+    /**
+     * Deeply combines objects, with later objects in parameters taking precedence over earlier ones. Does not combine arrays.
+     * @param objects Objects to combine
+     * @returns Combined object
+     */
+    combine<T extends Record<string, any | undefined>>(...objects: Array<Partial<T> | undefined>): T;
+  }
+}
+
+
+export function omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props> {
+  return props.reduce((result, prop) => {
+    if (typeof prop === "object") {
+      const keys = Object.keysOf(prop);
+      keys.forEach(key => delete (result as Partial<From>)[key]);
+    } else {
+      delete (result as Partial<From>)[prop];
+    }
+
+    return result;
+  }, { ...from } as Omit<From, Props>);
+}
+Object.omit = omit;
+
+export function pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props> {
+  return props.reduce((result, prop) => {
+    if (typeof prop === "object") {
+      const keys = Object.keysOf(prop);
+      keys.forEach(key => (result as Partial<From>)[key] = from[key]);
+    } else {
+      (result as Partial<From>)[prop] = from[prop];
+    }
+    return result;
+  }, {} as Pick<From, Props>);
+}
+Object.pick = pick;
+
+export function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T> {
+  const diffKeys = new Set([...Object.keysOf(source), ...Object.keysOf(target)]);
+  exclude?.forEach(key => diffKeys.delete(key));
+
+  return [...diffKeys.values()].reduce((acc, key, i, arr) => {
+    const sourceValue = JSON.stringify(source[key]);
+    const targetValue = JSON.stringify(target[key]);
+    if (sourceValue !== targetValue) acc[key] = target[key];
+    return acc;
+  }, {} as T);
+}
+Object.difference = difference;
+
+type Combinable<T extends Record<string, any>> = {
+  [key in keyof T]?: T[key] extends Record<string, any> ? Combinable<T[key]> : T[key];
+};
+
+export function combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<T> | undefined>): T {
+  return objects.reduce((acc: T, obj) => {
+    if (!obj) return acc;
+
+    for (const key in obj) {
+      if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        try {
+          acc[key] = combine(acc[key] as T, obj[key] as T) as any;
+        } catch (err) {
+          const error = err as Error;
+          if (error.message.includes('Maximum call stack size exceeded')) {
+            acc[key] = obj[key] as any;
+          } else throw err;
+        }
+      } else if (obj[key] !== undefined && obj[key] !== null && obj[key] !== '') {
+        // @ts-ignore
+        (acc[key] as Combinable<T>) = obj[key];
+      }
+    }
+    return acc;
+  }, {} as T) as T;
+}
+Object.combine = combine;

package/src/Extensions/Object/index.ts

@@ -1,82 +1,11 @@
-import { ValueOf } from "../../Types";
-import { Properties, properties } from "./properties";
-
-declare global {
-    interface ObjectConstructor {
-        /**
-         * Destructures object into array of [property, value]
-         * @param from Object to destruct
-         */
-        array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>
-
-        /**
-         * Omits properties from object, but for some reason the correct term is "extract"
-         * @param from Object to extract properties from
-         * @param props Properties to extract/Omit
-         */
-        extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>
-
-        /**
-         * Pick properties from object, but for some reason the correct term is "exclude"
-         * @param from Object to exclude properties from
-         * @param props Properties to exclude/pick
-         */
-        exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>
-
-        /**
-         * Returns true if object is empty
-         * @param obj Object to check
-         */
-        isNullOrUndefined(obj: any): obj is null | undefined
-
-        /**
-         * Destructures object into array of property keys
-         * @param from Object to destruct
-         */
-        keysOf<From extends {} = {}>(from: From): Array<keyof From>
-
-        omit<From extends {}, Exclude extends keyof From>(from: From, ...exclude: Exclude[]): Omit<From, Exclude>;
-
-        properties: Properties
-    }
-}
-
-function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
-    return Object.keysOf(from).map(prop => [prop, from[prop]]) as Array<[keyof From, ValueOf<From>]>;
-}
-Object.array = array;
-
-function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props> {
-    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From> 
-    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
-    _props.forEach(prop => delete from[prop as keyof From]);
-    return from;
-}
-Object.extract = extract;
-
-function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props> {
-    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From>
-    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
-    return Object.keysOf(from).reduce((result, prop) => {
-        if (_props.includes(prop as Props)) delete result[prop];
-        return result;
-    }, from);
-}
-Object.exclude = exclude;
-
-function isNullOrUndefined(obj: any): obj is null | undefined {
-    return obj === null || obj === undefined;
-}
-Object.isNullOrUndefined = isNullOrUndefined;
-
-function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From> {
-    return Object.keys(from) as Array<keyof From>;
-}
-Object.keysOf = keysOf;
-
-Object.properties = properties;
+import * as Array from './arrays.extension';
+import * as Booleans from './booleans.extension';
+import * as Extracts from './extracts.extension';
+import * as Properties from './properties.extension';
 
 export const ObjectExtensions = {
-    properties,
-    array, extract, exclude, isNullOrUndefined, keysOf, 
-};
+  ...Array,
+  ...Booleans,
+  ...Extracts,
+  ...Properties
+};

package/src/Extensions/Object/properties.extension.ts

@@ -0,0 +1,11 @@
+import { Properties, properties } from "./properties";
+
+declare global {
+  interface ObjectConstructor {
+    properties: Properties;
+  }
+}
+
+
+
+Object.properties = properties;

package/src/Extensions/Object/properties.ts

@@ -1,22 +1,21 @@
 import { PropertiesWith, If } from '../../Types';
-import { StringExtensions } from '../String';
 
 type PrimitiveMap = {
-    string: string;
-    number: number;
-    boolean: boolean;
-    undefined: undefined;
-    null: null;
-    object: object;
-    function: Function;
-    any: any;
-    Date: Date;
-    RegExp: RegExp;
-    Promise: Promise<any>;
-    Array: Array<any>;
-    Map: Map<any, any>;
-    Set: Set<any>;
-}
+  string: string;
+  number: number;
+  boolean: boolean;
+  undefined: undefined;
+  null: null;
+  object: object;
+  function: Function;
+  any: any;
+  Date: Date;
+  RegExp: RegExp;
+  Promise: Promise<any>;
+  Array: Array<any>;
+  Map: Map<any, any>;
+  Set: Set<any>;
+};
 
 /**
  * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
@@ -25,27 +24,27 @@ type PrimitiveMap = {
  * ): Object with properties from source that matches primitive type
  */
 export type Properties = {
-    [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]: 
-        <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) => 
-            If<AllowFunctions,
-                PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
-                PropertiesWith<PrimitiveMap[Key], Source>
-            >
-}
+  [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]:
+  <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) =>
+    If<AllowFunctions,
+      PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
+      PropertiesWith<PrimitiveMap[Key], Source>
+    >
+};
 
 export const properties: Properties = [
-    'string', 'number', 'boolean', 'undefined', 'null', 
-    'object', 'function', 'any', 
-    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+  'string', 'number', 'boolean', 'undefined', 'null',
+  'object', 'function', 'any',
+  'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
 ].reduce((result, primitive) => {
-    result[`get${StringExtensions.toPascalCase.bind(primitive)()}s` as keyof Properties] = function<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
-        return Object.keysOf<Source>(source).reduce((result, key) => {
-            if ((source[key] as any).constructor.name === primitive || 
-                (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
-                result[key] = source[key];
-            }
-            return result;
-        }, {} as any);
-    }
-    return result;
+  result[`get${primitive.convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
+    return Object.keysOf<Source>(source).reduce((result, key) => {
+      if ((source[key] as any).constructor.name === primitive ||
+        (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
+        result[key] = source[key];
+      }
+      return result;
+    }, {} as any);
+  };
+  return result;
 }, {} as Properties);

package/src/Extensions/String/case.extension.ts

@@ -0,0 +1,95 @@
+export type Case = 'camel' | 'pascal' | 'snake' | 'kebab' | 'lower' | 'upper';
+
+declare global {
+  interface String {
+    /**
+     * Converts string from one case to another.
+     * @param from Case to convert from
+     * @param to Cases to convert to, in order. If multiple cases are provided, they will be applied in order
+     */
+    convertCase<To extends Array<Case>, Return extends To extends [...Array<Case>, infer To] ? To : Case>(
+      from: Case,
+      ...to: To
+    ): (
+      Return extends 'upper' ? Uppercase<string>
+      : Return extends 'lower' ? Lowercase<string>
+      : Return extends 'pascal' ? Capitalize<string>
+      : Return extends 'camel' ? Uncapitalize<string>
+      : string
+    );
+  }
+}
+
+const caseMap: Record<Case, Record<Case, (str: string) => string>> = {
+  camel: {
+    camel: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    pascal: (str: string) => str[0].toUpperCase() + str.replace(/([A-Z])/g, (match) => ` ${match}`).slice(1),
+    snake: (str: string) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+    kebab: (str: string) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+  },
+  pascal: {
+    pascal: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str[0].toLowerCase() + str.slice(1),
+    snake: (str: string) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+    kebab: (str: string) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+  },
+  snake: {
+    snake: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str.replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+    pascal: (str: string) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+    kebab: (str: string) => str.replace(/_/g, '-'),
+  },
+  kebab: {
+    kebab: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str.replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+    pascal: (str: string) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+    snake: (str: string) => str.replace(/-/g, '_'),
+  },
+
+  lower: {
+    lower: (str) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str,
+    pascal: (str: string) => str[0].toUpperCase() + str.slice(1),
+    snake: (str: string) => str,
+    kebab: (str: string) => str,
+  },
+
+  upper: {
+    upper: (str) => str.toUpperCase(),
+    camel: (str: string) => str[0].toLowerCase() + str.slice(1),
+    pascal: (str: string) => str[0].toUpperCase() + str.toLowerCase().slice(1),
+    snake: (str: string) => str.replace(/ /g, '_'),
+    kebab: (str: string) => str.replace(/ /g, '-'),
+    lower: (str: string) => str.toLowerCase(),
+  }
+};
+
+export const convertCase = <
+  TValue extends string,
+  To extends Array<Case>,
+  Return extends To extends [...Array<Case>, infer To] ? To : Case
+>(
+  value: TValue,
+  from: Case,
+  ...to: To
+): (
+    Return extends 'upper' ? Uppercase<TValue>
+    : Return extends 'lower' ? Lowercase<TValue>
+    : Return extends 'pascal' ? Capitalize<TValue>
+    : Return extends 'camel' ? Uncapitalize<TValue>
+    : string
+  ) => to.reduce((str, toCase) => caseMap[from][toCase](str), value as string) as any;

package/src/Extensions/String/index.ts

@@ -0,0 +1,5 @@
+import * as Case from './case.extension';
+
+export const StringUtils = {
+  ...Case,
+}