danholibraryjs 1.11.0 → 2.0.0

package/dist/Extensions/Object/arrays.extension.d.ts

@@ -0,0 +1,17 @@
+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 declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+export declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;

package/dist/Extensions/Object/arrays.extension.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keysOf = exports.array = void 0;
+function array(from) {
+    return Object.entries(from);
+}
+exports.array = array;
+Object.array = array;
+function keysOf(from) {
+    return Object.keys(from);
+}
+exports.keysOf = keysOf;
+Object.keysOf = keysOf;

package/dist/Extensions/Object/booleans.extension.d.ts

@@ -0,0 +1,18 @@
+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 declare function areEqual<T extends object | null>(a?: T, b?: T): boolean;
+export declare function isNullOrUndefined(obj: any): obj is null | undefined;

package/dist/Extensions/Object/booleans.extension.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullOrUndefined = exports.areEqual = void 0;
+function areEqual(a, b) {
+    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[key], b[key]))
+                return false;
+        }
+    }
+    return true;
+}
+exports.areEqual = areEqual;
+Object.areEqual = areEqual;
+function isNullOrUndefined(obj) {
+    return obj === null || obj === undefined;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+Object.isNullOrUndefined = isNullOrUndefined;

package/dist/Extensions/Object/extracts.extension.d.ts

@@ -0,0 +1,38 @@
+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 declare function omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+export declare function pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+export declare function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+type Combinable<T extends Record<string, any>> = {
+    [key in keyof T]?: T[key] extends Record<string, any> ? Combinable<T[key]> : T[key];
+};
+export declare function combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<T> | undefined>): T;
+export {};

package/dist/Extensions/Object/extracts.extension.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combine = exports.difference = exports.pick = exports.omit = void 0;
+function omit(from, ...props) {
+    return props.reduce((result, prop) => {
+        if (typeof prop === "object") {
+            const keys = Object.keysOf(prop);
+            keys.forEach(key => delete result[key]);
+        }
+        else {
+            delete result[prop];
+        }
+        return result;
+    }, { ...from });
+}
+exports.omit = omit;
+Object.omit = omit;
+function pick(from, ...props) {
+    return props.reduce((result, prop) => {
+        if (typeof prop === "object") {
+            const keys = Object.keysOf(prop);
+            keys.forEach(key => result[key] = from[key]);
+        }
+        else {
+            result[prop] = from[prop];
+        }
+        return result;
+    }, {});
+}
+exports.pick = pick;
+Object.pick = pick;
+function difference(source, target, ...exclude) {
+    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;
+    }, {});
+}
+exports.difference = difference;
+Object.difference = difference;
+function combine(...objects) {
+    return objects.reduce((acc, 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], obj[key]);
+                }
+                catch (err) {
+                    const error = err;
+                    if (error.message.includes('Maximum call stack size exceeded')) {
+                        acc[key] = obj[key];
+                    }
+                    else
+                        throw err;
+                }
+            }
+            else if (obj[key] !== undefined && obj[key] !== null && obj[key] !== '') {
+                // @ts-ignore
+                acc[key] = obj[key];
+            }
+        }
+        return acc;
+    }, {});
+}
+exports.combine = combine;
+Object.combine = combine;

package/dist/Extensions/Object/index.d.ts

@@ -1,49 +1,10 @@
-import { ValueOf } from "../../Types";
-import { 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;
-    }
-}
-declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
-declare function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
-declare function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
-declare function isNullOrUndefined(obj: any): obj is null | undefined;
-declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;
-export declare const ObjectExtensions: {
-    properties: Properties;
-    array: typeof array;
-    extract: typeof extract;
-    exclude: typeof exclude;
-    isNullOrUndefined: typeof isNullOrUndefined;
-    keysOf: typeof keysOf;
-};
-export {};
+export declare const ObjectExtensions: {
+    omit<From extends {}, Props extends keyof From>(from: From, ...props: (Props | Partial<From>)[]): Omit<From, Props>;
+    pick<From_1 extends {}, Props_1 extends keyof From_1>(from: From_1, ...props: (Props_1 | Partial<From_1>)[]): Pick<From_1, Props_1>;
+    difference<T extends object>(source: T, target: T, ...exclude: (keyof T)[]): Omit<T, keyof T>;
+    combine<T_1 extends Record<string, any>>(...objects: ({ [key in keyof T_1]?: (T_1[key] extends Record<string, any> ? T_1[key] extends infer T_2 extends Record<string, any> ? { [key_1 in keyof T_2]?: (T_1[key][key_1] extends Record<string, any> ? T_1[key][key_1] extends infer T_3 extends Record<string, any> ? { [key_2 in keyof T_3]?: (T_1[key][key_1][key_2] extends Record<string, any> ? T_1[key][key_1][key_2] extends infer T_4 extends Record<string, any> ? { [key_3 in keyof T_4]?: (T_1[key][key_1][key_2][key_3] extends Record<string, any> ? T_1[key][key_1][key_2][key_3] extends infer T_5 extends Record<string, any> ? { [key_4 in keyof T_5]?: (T_1[key][key_1][key_2][key_3][key_4] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4] extends infer T_6 extends Record<string, any> ? { [key_5 in keyof T_6]?: (T_1[key][key_1][key_2][key_3][key_4][key_5] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4][key_5] extends infer T_7 extends Record<string, any> ? { [key_6 in keyof T_7]?: (T_1[key][key_1][key_2][key_3][key_4][key_5][key_6] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4][key_5][key_6] extends infer T_8 extends Record<string, any> ? { [key_7 in keyof T_8]?: (T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7] extends infer T_9 extends Record<string, any> ? { [key_8 in keyof T_9]?: (T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8] extends infer T_10 extends Record<string, any> ? { [key_9 in keyof T_10]?: (T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8][key_9] extends Record<string, any> ? T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8][key_9] extends infer T_11 extends Record<string, any> ? { [key_10 in keyof T_11]?: (T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8][key_9][key_10] extends Record<string, any> ? any : T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8][key_9][key_10]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8][key_9]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7][key_8]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4][key_5][key_6][key_7]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4][key_5][key_6]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4][key_5]) | undefined; } : never : T_1[key][key_1][key_2][key_3][key_4]) | undefined; } : never : T_1[key][key_1][key_2][key_3]) | undefined; } : never : T_1[key][key_1][key_2]) | undefined; } : never : T_1[key][key_1]) | undefined; } : never : T_1[key]) | undefined; } | undefined)[]): T_1;
+    areEqual<T_12 extends object | null>(a?: T_12 | undefined, b?: T_12 | undefined): boolean;
+    isNullOrUndefined(obj: any): obj is null | undefined;
+    array<From_2 extends {} = {}>(this: object, from: From_2): [keyof From_2, import("../..").ValueOf<From_2>][];
+    keysOf<From_3 extends {} = {}>(this: object, from: From_3): (keyof From_3)[];
+};

package/dist/Extensions/Object/index.js

@@ -1,38 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectExtensions = void 0;
-const properties_1 = require("./properties");
-function array(from) {
-    return Object.keysOf(from).map(prop => [prop, from[prop]]);
-}
-Object.array = array;
-function extract(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]);
-    return from;
-}
-Object.extract = extract;
-function exclude(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))
-            delete result[prop];
-        return result;
-    }, from);
-}
-Object.exclude = exclude;
-function isNullOrUndefined(obj) {
-    return obj === null || obj === undefined;
-}
-Object.isNullOrUndefined = isNullOrUndefined;
-function keysOf(from) {
-    return Object.keys(from);
-}
-Object.keysOf = keysOf;
-Object.properties = properties_1.properties;
-exports.ObjectExtensions = {
-    properties: properties_1.properties,
-    array, extract, exclude, isNullOrUndefined, keysOf,
-};
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectExtensions = void 0;
+const Array = __importStar(require("./arrays.extension"));
+const Booleans = __importStar(require("./booleans.extension"));
+const Extracts = __importStar(require("./extracts.extension"));
+const Properties = __importStar(require("./properties.extension"));
+exports.ObjectExtensions = {
+    ...Array,
+    ...Booleans,
+    ...Extracts,
+    ...Properties
+};

package/dist/Extensions/Object/properties.d.ts

@@ -1,28 +1,28 @@
-import { PropertiesWith, If } from '../../Types';
-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>;
-};
-/**
- * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
- *  source: Source,
- *  allowFunctions: AllowFunctions = false
- * ): 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>>;
-};
-export declare const properties: Properties;
-export {};
+import { PropertiesWith, If } from '../../Types';
+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>;
+};
+/**
+ * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
+ *  source: Source,
+ *  allowFunctions: AllowFunctions = false
+ * ): 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>>;
+};
+export declare const properties: Properties;
+export {};

package/dist/Extensions/Object/properties.extension.d.ts

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

package/dist/Extensions/Object/properties.extension.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const properties_1 = require("./properties");
+Object.properties = properties_1.properties;

package/dist/Extensions/Object/properties.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.properties = void 0;
-const String_1 = require("../String");
-exports.properties = [
-    'string', 'number', 'boolean', 'undefined', 'null',
-    'object', 'function', 'any',
-    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
-].reduce((result, primitive) => {
-    result[`get${String_1.StringExtensions.toPascalCase.bind(primitive)()}s`] = function (source, withFunctions = false) {
-        return Object.keysOf(source).reduce((result, key) => {
-            if (source[key].constructor.name === primitive ||
-                (withFunctions && typeof source[key] === 'function' && source[key]).constructor.name === primitive) {
-                result[key] = source[key];
-            }
-            return result;
-        }, {});
-    };
-    return result;
-}, {});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.properties = void 0;
+exports.properties = [
+    'string', 'number', 'boolean', 'undefined', 'null',
+    'object', 'function', 'any',
+    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+    result[`get${primitive.convertCase('camel', 'pascal')}s`] = function (source, withFunctions = false) {
+        return Object.keysOf(source).reduce((result, key) => {
+            if (source[key].constructor.name === primitive ||
+                (withFunctions && typeof source[key] === 'function' && source[key]).constructor.name === primitive) {
+                result[key] = source[key];
+            }
+            return result;
+        }, {});
+    };
+    return result;
+}, {});

package/dist/Extensions/String/case.extension.d.ts

@@ -0,0 +1,12 @@
+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);
+    }
+}
+export declare const convertCase: <TValue extends string, To extends Case[], Return extends To extends [...Case[], infer To_1] ? To_1 : 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;

package/dist/Extensions/String/case.extension.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCase = void 0;
+const caseMap = {
+    camel: {
+        camel: (str) => str,
+        lower: (str) => str.toLowerCase(),
+        upper: (str) => str.toUpperCase(),
+        pascal: (str) => str[0].toUpperCase() + str.replace(/([A-Z])/g, (match) => ` ${match}`).slice(1),
+        snake: (str) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+        kebab: (str) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+    },
+    pascal: {
+        pascal: (str) => str,
+        lower: (str) => str.toLowerCase(),
+        upper: (str) => str.toUpperCase(),
+        camel: (str) => str[0].toLowerCase() + str.slice(1),
+        snake: (str) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+        kebab: (str) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+    },
+    snake: {
+        snake: (str) => str,
+        lower: (str) => str.toLowerCase(),
+        upper: (str) => str.toUpperCase(),
+        camel: (str) => str.replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+        pascal: (str) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+        kebab: (str) => str.replace(/_/g, '-'),
+    },
+    kebab: {
+        kebab: (str) => str,
+        lower: (str) => str.toLowerCase(),
+        upper: (str) => str.toUpperCase(),
+        camel: (str) => str.replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+        pascal: (str) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+        snake: (str) => str.replace(/-/g, '_'),
+    },
+    lower: {
+        lower: (str) => str.toLowerCase(),
+        upper: (str) => str.toUpperCase(),
+        camel: (str) => str,
+        pascal: (str) => str[0].toUpperCase() + str.slice(1),
+        snake: (str) => str,
+        kebab: (str) => str,
+    },
+    upper: {
+        upper: (str) => str.toUpperCase(),
+        camel: (str) => str[0].toLowerCase() + str.slice(1),
+        pascal: (str) => str[0].toUpperCase() + str.toLowerCase().slice(1),
+        snake: (str) => str.replace(/ /g, '_'),
+        kebab: (str) => str.replace(/ /g, '-'),
+        lower: (str) => str.toLowerCase(),
+    }
+};
+const convertCase = (value, from, ...to) => to.reduce((str, toCase) => caseMap[from][toCase](str), value);
+exports.convertCase = convertCase;

package/dist/Extensions/String/index.d.ts

@@ -0,0 +1,4 @@
+import * as Case from './case.extension';
+export declare const StringUtils: {
+    convertCase: <TValue extends string, To extends Case.Case[], Return extends To extends [...Case.Case[], infer To_1] ? To_1 : Case.Case>(value: TValue, from: Case.Case, ...to: To) => Return extends "upper" ? Uppercase<TValue> : Return extends "lower" ? Lowercase<TValue> : Return extends "pascal" ? Capitalize<TValue> : Return extends "camel" ? Uncapitalize<TValue> : string;
+};

package/dist/Extensions/String/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUtils = void 0;
+const Case = __importStar(require("./case.extension"));
+exports.StringUtils = {
+    ...Case,
+};

package/dist/Extensions/String.d.ts

@@ -1,36 +1,36 @@
-import IReplacement from "../Interfaces/IReplacement";
-declare global {
-    interface String {
-        /**
-         * Uppercases first letter of string
-         */
-        toPascalCase(): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toSnakeCase(replaceOptions?: IReplacement): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toKebabCase(replaceOptions?: IReplacement): string;
-        /**
-         * String.substring but accepting negative numbers to cut from length
-         * @param start Start of string. 0 indexed, if negative number, subtracts number from length
-         * @param end End of string. 0 indexed, if negative number, substracts number from length
-         */
-        clip(start: number, end?: number): string;
-    }
-}
-declare function toPascalCase(this: string): string;
-declare function toSnakeCase(this: string, replaceOptions: IReplacement): string;
-declare function toKebabCase(this: string, replaceOptions: IReplacement): string;
-declare function clip(this: string, start: number, end?: number): string;
-export declare const StringExtensions: {
-    toPascalCase: typeof toPascalCase;
-    toSnakeCase: typeof toSnakeCase;
-    toKebabCase: typeof toKebabCase;
-    clip: typeof clip;
-};
-export {};
+import IReplacement from "../Interfaces/IReplacement";
+declare global {
+    interface String {
+        /**
+         * Uppercases first letter of string
+         */
+        toPascalCase(): string;
+        /**
+         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
+         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
+         */
+        toSnakeCase(replaceOptions?: IReplacement): string;
+        /**
+         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
+         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
+         */
+        toKebabCase(replaceOptions?: IReplacement): string;
+        /**
+         * String.substring but accepting negative numbers to cut from length
+         * @param start Start of string. 0 indexed, if negative number, subtracts number from length
+         * @param end End of string. 0 indexed, if negative number, substracts number from length
+         */
+        clip(start: number, end?: number): string;
+    }
+}
+declare function toPascalCase(this: string): string;
+declare function toSnakeCase(this: string, replaceOptions: IReplacement): string;
+declare function toKebabCase(this: string, replaceOptions: IReplacement): string;
+declare function clip(this: string, start: number, end?: number): string;
+export declare const StringExtensions: {
+    toPascalCase: typeof toPascalCase;
+    toSnakeCase: typeof toSnakeCase;
+    toKebabCase: typeof toKebabCase;
+    clip: typeof clip;
+};
+export {};