danholibraryjs 2.0.1 → 2.0.3

package/README.md

@@ -26,3 +26,4 @@ import { ... } from 'DanhoLibraryJS';
 * [Extensions](/docs/Extensions.md)
 * [Interfaces](/docs/Interfaces.md)
 * [Types](/docs/Types.md)
+* [Utils](/docs/Utils.md)

package/dist/Extensions/Array/random.extension.d.ts

@@ -15,9 +15,8 @@ declare global {
          * @param items An array of tuples where each tuple contains an item and its corresponding weight.
          * @returns A randomly selected item based on the provided weights.
          */
-        randomWithPercentages(items: [item: T, weight: number][]): T;
+        randomWithPercentages(items: Array<[item: T, weight: number]>): T;
     }
 }
 export declare function random<T>(this: Array<T>): T;
 export declare function shuffle<T>(this: Array<T>): Array<T>;
-export declare function randomWithPercentages<T>(items: [item: T, weight: number][]): T;

package/dist/Extensions/Array/random.extension.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomWithPercentages = exports.shuffle = exports.random = void 0;
+exports.shuffle = exports.random = void 0;
 function random() {
     const randomIndex = Math.floor(Math.random() * this.length);
     return this[randomIndex];
@@ -12,24 +12,3 @@ function shuffle() {
 }
 exports.shuffle = shuffle;
 Array.prototype.shuffle = shuffle;
-function randomWithPercentages(items) {
-    if (items.length === 0)
-        throw new Error('Items array cannot be empty');
-    // Calculate total weight in case weights don't sum to 100
-    const totalWeight = items.reduce((sum, [, weight]) => sum + weight, 0);
-    if (totalWeight === 0)
-        throw new Error('Total weight must be greater than zero');
-    // Generate random number between 0 and totalWeight
-    const random = Math.random() * totalWeight;
-    // Find the item that corresponds to this random value
-    let currentWeight = 0;
-    for (const [item, weight] of items) {
-        currentWeight += weight;
-        if (random <= currentWeight) {
-            return item;
-        }
-    }
-    throw new Error('Unable to select an item based on weights');
-}
-exports.randomWithPercentages = randomWithPercentages;
-Array.prototype.randomWithPercentages = randomWithPercentages;

package/dist/Extensions/Array/string.extension.d.ts

@@ -2,12 +2,11 @@ declare global {
     interface Array<T> {
         /**
          * Joins the elements of the array into a string, with optional custom separators.
-         * @param args An array of strings or undefined values to be used as separators between elements.
-         * @param separator The default separator to use between elements if args is not provided or undefined.
-         * @param endSeparator The separator to use before the last element.
+         * @param separator The default separator to use between elements. Defaults to ','.
+         * @param endSeparator The separator to use before the last element. Default is '&'.
          * @returns A string with the joined elements.
          */
-        join(args?: Array<string | undefined>, separator?: string, endSeparator?: string): string;
+        join(separator?: string, endSeparator?: string): string;
     }
 }
 export declare function join<T>(this: Array<T>, separator?: string, endSeparator?: string): string;

package/dist/Extensions/Number.d.ts

@@ -4,10 +4,10 @@ type Separators = {
 };
 declare global {
     interface Number {
-        toSeparationString(separators: Partial<Separators>): string;
+        toSeparationString(separators?: Partial<Separators>): string;
         toRomanNumeral(): string;
     }
 }
-export declare function toSeparationString(this: number, separators: Partial<Separators>): string;
+export declare function toSeparationString(this: number, separators?: Partial<Separators>): string;
 export declare function toRomanNumeral(this: number): string;
 export {};

package/dist/Extensions/Number.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toRomanNumeral = exports.toSeparationString = void 0;
 function toSeparationString(separators) {
-    const { thousand = '.', decimal = '.' } = 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;

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

@@ -6,6 +6,18 @@ declare global {
          * @param from Object to destruct
          */
         array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+        /**
+         * Destructures object into array of property keys or values depending on selector
+         * @param from Object to destruct
+         * @param selector Selects whether to return keys or values
+         */
+        array<From extends {} = {}>(from: From, selector: 'keys'): Array<keyof From>;
+        /**
+         * Destructures object into array of property keys or values depending on selector
+         * @param from Object to destruct
+         * @param selector Selects whether to return keys or values
+         */
+        array<From extends {} = {}>(from: From, selector: 'values'): Array<ValueOf<From>>;
         /**
          * Destructures object into array of property keys
          * @param from Object to destruct
@@ -14,4 +26,6 @@ declare global {
     }
 }
 export declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+export declare function array<From extends {} = {}>(this: object, from: From, selector: 'keys'): Array<keyof From>;
+export declare function array<From extends {} = {}>(this: object, from: From, selector: 'values'): Array<ValueOf<From>>;
 export declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;

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

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.keysOf = exports.array = void 0;
-function array(from) {
-    return Object.entries(from);
+function array(from, selector) {
+    const entries = Object.entries(from);
+    switch (selector) {
+        case 'keys': return entries.map(([key]) => key);
+        case 'values': return entries.map(([, value]) => value);
+        default: return entries;
+    }
 }
 exports.array = array;
 Object.array = array;

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

@@ -13,24 +13,24 @@ declare global {
          */
         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
+         * Returns the difference between two objects (properties where values differ)
          * @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
+         * @param exclude Properties to exclude from comparison
+         * @returns Object with properties where values differ between source and target, excluding specified properties
          */
-        difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+        difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Partial<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;
+        combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<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>;
+export declare function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Partial<T>;
 type Combinable<T extends Record<string, any>> = {
     [key in keyof T]?: T[key] extends Record<string, any> ? Combinable<T[key]> : T[key];
 };

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

@@ -19,9 +19,13 @@ 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]);
+            keys.forEach(key => {
+                if (key in from) {
+                    result[key] = from[key];
+                }
+            });
         }
-        else {
+        else if (prop in from) {
             result[prop] = from[prop];
         }
         return result;
@@ -30,13 +34,16 @@ function pick(from, ...props) {
 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];
+    const excludeSet = new Set(exclude);
+    const allKeys = new Set([...Object.keysOf(source), ...Object.keysOf(target)]);
+    return [...allKeys].reduce((acc, key) => {
+        if (excludeSet.has(key))
+            return acc;
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (JSON.stringify(sourceValue) !== JSON.stringify(targetValue)) {
+            acc[key] = targetValue;
+        }
         return acc;
     }, {});
 }

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

@@ -7,7 +7,7 @@ exports.properties = [
     'object', 'function', 'any',
     'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
 ].reduce((result, primitive) => {
-    result[`get${(0, case_extension_1.convertCase)('camel', 'pascal')}s`] = function (source, withFunctions = false) {
+    result[`get${case_extension_1.convertCase.call(primitive, '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

@@ -9,4 +9,4 @@ declare global {
         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;
+export declare function convertCase<TValue extends string, To extends Array<Case>, Return extends To extends [...Array<Case>, infer To] ? To : Case>(this: 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

@@ -51,5 +51,8 @@ const caseMap = {
         lower: (str) => str.toLowerCase(),
     }
 };
-const convertCase = (value, from, ...to) => to.reduce((str, toCase) => caseMap[from][toCase](str), value);
+function convertCase(from, ...to) {
+    return to.reduce((str, toCase) => caseMap[from][toCase](str), this);
+}
 exports.convertCase = convertCase;
+String.prototype.convertCase = convertCase;

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

@@ -1 +1,2 @@
 export * from './case.extension';
+export * from './string.extension';

package/dist/Extensions/String/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./case.extension"), exports);
+__exportStar(require("./string.extension"), exports);

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

@@ -0,0 +1,6 @@
+declare global {
+    interface String {
+        truncate(length: number, ellipsis?: string): string;
+    }
+}
+export declare function truncate(this: string, length: number, ellipsis?: string): string;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncate = void 0;
+function truncate(length, ellipsis = "...") {
+    if (this.length <= length)
+        return this;
+    return this.slice(0, length - ellipsis.length) + ellipsis;
+}
+exports.truncate = truncate;
+String.prototype.truncate = truncate;

package/dist/Types/Able.d.ts

@@ -5,7 +5,7 @@ export type Functionable<T, Args extends any[] = []> = T | ((...args: Args) => T
 /**
  * Item is Promise<T> or T
  */
-export type Promisable<T> = T | Promise<T>;
+export type Promiseable<T> = T | Promise<T>;
 /**
  * Item is T or null
  */

package/dist/Utils/NumberUtils.d.ts

@@ -1 +1,6 @@
 export declare function between(min: number, max: number): number;
+export declare function randomWithPercentages<T>(items: [item: T, weight: number][]): T;
+export declare const NumberUtils: {
+    between: typeof between;
+    randomWithPercentages: typeof randomWithPercentages;
+};

package/dist/Utils/NumberUtils.js

@@ -1,7 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.between = void 0;
+exports.NumberUtils = exports.randomWithPercentages = exports.between = void 0;
 function between(min, max) {
     return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 exports.between = between;
+function randomWithPercentages(items) {
+    if (items.length === 0)
+        throw new Error('Items array cannot be empty');
+    // Calculate total weight in case weights don't sum to 100
+    const totalWeight = items.reduce((sum, [, weight]) => sum + weight, 0);
+    if (totalWeight === 0)
+        throw new Error('Total weight must be greater than zero');
+    // Generate random number between 0 and totalWeight
+    const random = Math.random() * totalWeight;
+    // Find the item that corresponds to this random value
+    let currentWeight = 0;
+    for (const [item, weight] of items) {
+        currentWeight += weight;
+        if (random <= currentWeight) {
+            return item;
+        }
+    }
+    throw new Error('Unable to select an item based on weights');
+}
+exports.randomWithPercentages = randomWithPercentages;
+exports.NumberUtils = {
+    between,
+    randomWithPercentages,
+};

package/dist/Utils/StringUtils.d.ts

@@ -1,3 +1,8 @@
 export declare function classNames(...args: Array<any>): string;
 export declare function randomId(length?: number): string;
 export declare function pluralize(countable: number | ArrayLike<any> | Map<any, any>, singular: string, plural?: string): string;
+export declare const StringUtils: {
+    classNames: typeof classNames;
+    randomId: typeof randomId;
+    pluralize: typeof pluralize;
+};

package/dist/Utils/StringUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluralize = exports.randomId = exports.classNames = void 0;
+exports.StringUtils = exports.pluralize = exports.randomId = exports.classNames = void 0;
 function classNames(...args) {
     return args.reduce((acc, arg) => {
         if (!arg)
@@ -45,3 +45,8 @@ function pluralize(countable, singular, plural) {
     return `${singular}s`;
 }
 exports.pluralize = pluralize;
+exports.StringUtils = {
+    classNames,
+    randomId,
+    pluralize
+};

package/dist/Utils/TimeUtils/index.d.ts

@@ -1,4 +1,7 @@
 export declare const TimeUtils: {
+    ensureStartZero(num: number): string;
+    get12HourFormat(hour: number): string;
+    get24HourFormat(hour: number): string;
     throttle<T>(throttleId: string, callback: () => T, cooldown: number): T;
     wrapInThrottle<T_1>(callback: (...args: T_1[]) => void, cooldown: number): (...args: T_1[]) => void;
     isThrottleOnCooldown(throttleId: string): boolean;

package/dist/Utils/TimeUtils/index.js

@@ -27,8 +27,10 @@ exports.TimeUtils = void 0;
 const Debounce = __importStar(require("./debounce.util"));
 const Functions = __importStar(require("./functions.util"));
 const Throttle = __importStar(require("./throttle.util"));
+const StringUtils = __importStar(require("./string.util"));
 exports.TimeUtils = {
     ...Functions,
     ...Debounce,
     ...Throttle,
+    ...StringUtils,
 };

package/dist/Utils/TimeUtils/string.util.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureStartZero(num: number): string;
+export declare function get12HourFormat(hour: number): string;
+export declare function get24HourFormat(hour: number): string;

package/dist/Utils/TimeUtils/string.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get24HourFormat = exports.get12HourFormat = exports.ensureStartZero = void 0;
+function ensureStartZero(num) {
+    return num < 10 ? `0${num}` : num.toString();
+}
+exports.ensureStartZero = ensureStartZero;
+function get12HourFormat(hour) {
+    if (hour === 0)
+        return '12am';
+    if (hour > 12)
+        return `${hour - 12}pm`;
+    return `${hour}am`;
+}
+exports.get12HourFormat = get12HourFormat;
+function get24HourFormat(hour) {
+    return ensureStartZero(hour);
+}
+exports.get24HourFormat = get24HourFormat;

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './Classes';
 export * from './Extensions';
 export * from './Interfaces';
 export * from './Types';
+export * from './Utils';

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./Classes"), exports);
 __exportStar(require("./Extensions"), exports);
 __exportStar(require("./Interfaces"), exports);
 __exportStar(require("./Types"), exports);
+__exportStar(require("./Utils"), exports);