danholibraryjs 1.10.0 → 2.0.0

package/dist/Extensions/Array.d.ts

@@ -1,5 +1,4 @@
-export {};
-type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
+export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
 declare global {
     interface Array<T> {
         /**
@@ -33,6 +32,21 @@ declare global {
          * @param callback Function to execute
          * @returns Array of results
          */
-        nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>;
+        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
     }
 }
+declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
+declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
+declare function remove<T>(this: Array<T>, value: T | number): Array<T>;
+declare function random<T>(this: Array<T>): T;
+declare function index<T>(this: Array<T>, i: number): T;
+declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;
+export declare const ArrayExtensions: {
+    add: typeof add;
+    update: typeof update;
+    remove: typeof remove;
+    random: typeof random;
+    index: typeof index;
+    nth: typeof nth;
+};
+export {};

package/dist/Extensions/Array.js

@@ -49,15 +49,3 @@ exports.ArrayExtensions = {
     add, update, remove,
     random, index, nth
 };
-Array.prototype.nth = function (every, callback) {
-    const result = new Array();
-    let collection = new Array();
-    for (let i = 0; i < this.length; i++) {
-        collection.push(this[i]);
-        if (i % every === 0) {
-            result.push(callback(collection, i, this));
-            collection = new Array();
-        }
-    }
-    return result;
-};

package/dist/Extensions/Function.d.ts

@@ -1,3 +1,4 @@
+import { Functionable } from "../Types";
 declare global {
     interface Function {
         /**
@@ -5,10 +6,24 @@ declare global {
          * @param obj Object to check
          */
         is(obj: any): obj is Function;
+        /**
+         * Resolves a Functionable<T> to T, if it's a function, it will be called with the provided arguments and its return value will be returned, otherwise the value itself will be returned.
+         * @param functionable The Functionable<T> to resolve
+         * @param args Arguments to call the function with if functionable is a function
+         */
+        resolveFunctionable<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>, ...args: TArgs): T;
+        /**
+         * Forces a Functionable<T> to be a function, if it's already a function, it will be returned as is, otherwise a function that returns the value will be returned.
+         * @param functionable The Functionable<T> to force to be a function
+         */
+        forceFunction<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>): (...args: TArgs) => T;
     }
 }
-declare function is(obj: any): obj is Function;
+export declare function is(obj: any): obj is Function;
+export declare function resolveFunctionable<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>, ...args: TArgs): T;
+export declare function forceFunction<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>): (...args: TArgs) => T;
 export declare const FunctionExtensions: {
     is: typeof is;
+    resolveFunctionable: typeof resolveFunctionable;
+    forceFunction: typeof forceFunction;
 };
-export {};

package/dist/Extensions/Function.js

@@ -1,10 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionExtensions = void 0;
+exports.FunctionExtensions = exports.forceFunction = exports.resolveFunctionable = exports.is = void 0;
 function is(obj) {
     return typeof obj === 'function';
 }
+exports.is = is;
 Function.is = is;
+function resolveFunctionable(functionable, ...args) {
+    return is(functionable) ? functionable(...args) : functionable;
+}
+exports.resolveFunctionable = resolveFunctionable;
+Function.resolveFunctionable = resolveFunctionable;
+function forceFunction(functionable) {
+    return is(functionable) ? functionable : () => functionable;
+}
+exports.forceFunction = forceFunction;
+Function.forceFunction = forceFunction;
 exports.FunctionExtensions = {
-    is
+    is,
+    resolveFunctionable,
+    forceFunction
 };

package/dist/Extensions/Number.d.ts

@@ -0,0 +1,13 @@
+type Separators = {
+    thousand: string;
+    decimal: string;
+};
+declare global {
+    interface Number {
+        toSeparationString(separators: Partial<Separators>): string;
+        toRomanNumeral(): string;
+    }
+}
+export declare function toSeparationString(this: number, separators: Partial<Separators>): string;
+export declare function toRomanNumeral(this: number): string;
+export {};

package/dist/Extensions/Number.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRomanNumeral = exports.toSeparationString = void 0;
+function toSeparationString(separators) {
+    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;
+}
+exports.toSeparationString = toSeparationString;
+Number.prototype.toSeparationString = toSeparationString;
+function toRomanNumeral() {
+    if (this <= 0 || this >= 4000)
+        throw new RangeError('Number must be between 1 and 3999 to convert to Roman numeral');
+    const numeralMap = [
+        [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;
+    }, '');
+}
+exports.toRomanNumeral = toRomanNumeral;
+Number.prototype.toRomanNumeral = toRomanNumeral;

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;
+    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)[];
 };
-export {};

package/dist/Extensions/Object/index.js

@@ -1,38 +1,36 @@
 "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 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;
+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 = {
-    properties: properties_1.properties,
-    array, extract, exclude, isNullOrUndefined, keysOf,
+    ...Array,
+    ...Booleans,
+    ...Extracts,
+    ...Properties
 };

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,13 +1,12 @@
 "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) {
+    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) {

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/index.d.ts

@@ -2,16 +2,5 @@ export * from './Array';
 export * from './Document';
 export * from './Map';
 export * from './Object';
+export * from './Number';
 export * from './String';
-declare global {
-    interface BooleanConstructor {
-        /**
-         * Parses string to boolean. Will only return true if value === "true" otherwise false
-         */
-        parseBoolean(value: string): boolean;
-    }
-}
-declare function parseBoolean(value: string): boolean;
-export declare const BooleanExtensions: {
-    parseBoolean: typeof parseBoolean;
-};