danholibraryjs 1.10.0 → 2.0.0

package/dist/Classes/DanhoLogger.d.ts

@@ -0,0 +1,23 @@
+type LogOptions = {
+    name?: string;
+    color?: string;
+    preferCollapsed?: boolean;
+};
+export default class DanhoLogger {
+    name: string;
+    color?: string;
+    private _preferCollapsed;
+    constructor(options?: LogOptions);
+    private _getPrefix;
+    private _log;
+    log(...args: any[]): this;
+    warn(...args: any[]): this;
+    error(...args: any[]): this;
+    group(...args: any[]): this;
+    groupCollapsed(...args: any[]): this;
+    groupEnd(...args: any[]): this;
+    time(label: string): this;
+    timeEnd(label: string): this;
+    table(data: any, columns?: string[]): this;
+}
+export {};

package/dist/Classes/DanhoLogger.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DanhoLogger {
+    name;
+    color;
+    _preferCollapsed;
+    constructor(options = {}) {
+        this.name = options.name || 'DanhoLogger';
+        this.color = options.color;
+        this._preferCollapsed = options.preferCollapsed ?? false;
+    }
+    _getPrefix() {
+        return {
+            prefix: `%c[${this.name}]`,
+            style: `color: ${this.color || 'inherit'}; font-weight: bold;`
+        };
+    }
+    _log(type, ...args) {
+        const { prefix, style } = this._getPrefix();
+        console[type](prefix, style, ...args);
+        return this;
+    }
+    log(...args) {
+        return this._log('log', ...args);
+    }
+    warn(...args) {
+        return this._log('warn', ...args);
+    }
+    error(...args) {
+        return this._log('error', ...args);
+    }
+    group(...args) {
+        const { prefix, style } = this._getPrefix();
+        const groupMethod = this._preferCollapsed ? console.groupCollapsed : console.group;
+        groupMethod(prefix, style, ...args);
+        return this;
+    }
+    groupCollapsed(...args) {
+        const { prefix, style } = this._getPrefix();
+        console.groupCollapsed(prefix, style, ...args);
+        return this;
+    }
+    groupEnd(...args) {
+        if (args.length)
+            console.log(...args);
+        console.groupEnd();
+        return this;
+    }
+    time(label) {
+        const { prefix } = this._getPrefix();
+        console.time(`${prefix} ${label}`);
+        return this;
+    }
+    timeEnd(label) {
+        const { prefix } = this._getPrefix();
+        console.timeEnd(`${prefix} ${label}`);
+        return this;
+    }
+    table(data, columns) {
+        this.log();
+        console.table(data, columns);
+        return this;
+    }
+}
+exports.default = DanhoLogger;

package/dist/Classes/Events/EventEmitter.d.ts

@@ -60,7 +60,7 @@ export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>>
      * @param event Event to emit
      * @param args Arguments for the event
      * @fires event
-     * @returns Array of listeners' reponses
+     * @returns Array of listeners' responses
      */
     emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): Array<Return>;
     /**

package/dist/Classes/Events/EventEmitter.js

@@ -77,7 +77,7 @@ class EventEmitter {
      * @param event Event to emit
      * @param args Arguments for the event
      * @fires event
-     * @returns Array of listeners' reponses
+     * @returns Array of listeners' responses
      */
     emit(event, ...args) {
         return this._events.emit(event, ...args);

package/dist/Classes/Time/Date.d.ts

@@ -55,6 +55,7 @@ declare class DanhoDate {
      */
     get hours(): number;
     set hours(value: number);
+    get isAM(): boolean;
     get isPM(): boolean;
     /**
      * Minutes of the date

package/dist/Classes/Time/Date.js

@@ -126,8 +126,11 @@ class DanhoDate {
      */
     get hours() { return this.date.getHours(); }
     set hours(value) { this.date.setHours(value); }
+    get isAM() {
+        return this.hours < 12;
+    }
     get isPM() {
-        return this.hours > 11;
+        return this.hours >= 12;
     }
     /**
      * Minutes of the date

package/dist/Classes/Time/Time.d.ts

@@ -1,3 +1,4 @@
+import { Autocomplete } from "../../Types";
 import { LongMonth } from "../../Types/Date";
 /** '2s' or 2000 */
 export type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
@@ -5,11 +6,11 @@ export type TimeString = `${number}${TimeUnit}`;
 export type TimeDelay = number | TimeString;
 export declare const ValidTime: RegExp;
 /**
- * Converts input into milliseconds
+ * Converts input into milliseconds. Supports multiple time units in one string by space separation. E.g. 1h 30m
  * @param input Input to convert to ms. 1s | 2m | 3h | 1M | 60000
  * @returns Millisecond value of input
  */
-export declare function ms(input: TimeDelay): number;
+export declare function ms(input: Autocomplete<TimeDelay>): number;
 /**
  * Time utility class
  * @borrows TimeDelay
@@ -35,7 +36,7 @@ export declare class Time {
     static DoubleDigit(value: number): string;
     static th(value: number, includeValue?: boolean): string;
     /**
-     * Array of names of the months. 0 idnexed
+     * Array of names of the months. 0 indexed
      */
     static get MonthNames(): LongMonth[];
     /**
@@ -60,6 +61,6 @@ export declare class Time {
     static get year(): number;
     /** Average month in milliseconds */
     static get avgMonth(): number;
-    static ms(input: TimeDelay): number;
+    static ms(input: Autocomplete<TimeDelay>): number;
 }
 export default Time;

package/dist/Classes/Time/Time.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Time = exports.ms = exports.ValidTime = void 0;
 exports.ValidTime = /^(\d+(?:\.|,)?\d*)(ms|s|m|h|d|w|M|y)$/;
 /**
- * Converts input into milliseconds
+ * Converts input into milliseconds. Supports multiple time units in one string by space separation. E.g. 1h 30m
  * @param input Input to convert to ms. 1s | 2m | 3h | 1M | 60000
  * @returns Millisecond value of input
  */
 function ms(input) {
+    return input.toString().split(' ').reduce((result, unit) => result += msSingular(unit), 0);
+}
+exports.ms = ms;
+function msSingular(input) {
     if (typeof input === 'number')
         return input;
     const match = input.match(exports.ValidTime);
@@ -28,7 +32,6 @@ function ms(input) {
     ]);
     return parseInt(value) * units.get(unit);
 }
-exports.ms = ms;
 /**
  * Time utility class
  * @borrows TimeDelay
@@ -73,10 +76,10 @@ class Time {
         return includeValue ? value + th : th;
     }
     /**
-     * Array of names of the months. 0 idnexed
+     * Array of names of the months. 0 indexed
      */
     static get MonthNames() {
-        return new Array('Janurary', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December');
+        return new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December');
     }
     /**
      * Array of names of the days of the week. 0 indexed

package/dist/Classes/index.d.ts

@@ -1,3 +1,4 @@
 export * from './Events';
 export * from './Time';
+export * from './DanhoLogger';
 export * from './store';

package/dist/Classes/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Events"), exports);
 __exportStar(require("./Time"), exports);
+__exportStar(require("./DanhoLogger"), exports);
 __exportStar(require("./store"), exports);

package/dist/Classes/store.d.ts

@@ -1,6 +1,9 @@
 import { Arrayable } from "../Types";
 import { EventEmitter } from "./Events";
 export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
+export type Actions<State, ActionTypes extends Record<string, any[]>> = {
+    [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>>;
+};
 /**
  * EventEmitter, but it stores state and handles state change with reducers
  *
@@ -64,16 +67,9 @@ export type Reducer<State, Types extends Record<string, any[]>, Action extends k
  *
  * ```
  */
-export declare class Store<State extends object, ActionTypes extends Record<string, any[]>, Actions extends {
-    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
-} = {
-    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
-}> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
-    constructor(state: State, actions?: {
-        [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>>;
-    });
+export declare class Store<State extends object, ActionTypes extends Record<string, any[]>, StoreActions extends Actions<State, ActionTypes> = Actions<State, ActionTypes>> extends EventEmitter<Record<keyof StoreActions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions?: StoreActions);
     private _state;
     get state(): State;
     dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
 }
-export default Store;

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

@@ -0,0 +1,42 @@
+import { Arrayable } from "../../Types";
+declare global {
+    interface Array<T> {
+        /**
+         * Returns the first `count` elements from the array.
+         * @param count Number of elements to take.
+         * @returns Array containing the first `count` elements.
+         */
+        take(count: number): Array<T>;
+        /**
+         * Returns a new array with only unique elements from the original array.
+         * @returns An array containing only unique elements.
+         */
+        unique(): Array<T>;
+        /**
+         * Splits the array into chunks of a specified size or by a splitter function.
+         * @param chunkSizeOrSplitter The size of each chunk or a function that determines where to split the array.
+         * @returns An array of arrays, where each sub-array is a chunk of the original array.
+         */
+        splitBy(chunkSizeOrSplitter: number | ((value: T, index: number, array: Array<T>) => boolean)): Array<Array<T>>;
+        /**
+         * Groups the elements of the array based on a key selector function.
+         * @param keySelector A function that selects a key for each element in the array.
+         * @returns A Map where each key is a group identifier and the value is an array of elements in that group.
+         */
+        groupBy<K>(keySelector: (value: T, index: number, array: Array<T>) => K): Map<K, Array<T>>;
+    }
+    interface ArrayConstructor {
+        /**
+         * Forces an arrayable object into an array
+         * @param arrayable The arrayable object to force into an array
+         * @returns An array containing the elements of the input or the single value.
+         */
+        forceArray<T>(arrayable: Arrayable<T>): Array<T>;
+    }
+}
+export declare function take<T>(this: Array<T>, count: number): Array<T>;
+export declare function forceArray<T>(arrayable: Arrayable<T>): Array<T>;
+export declare function unique<T>(this: Array<T>): Array<T>;
+export declare function splitBy<T>(this: Array<T>, chunkSize: number): Array<Array<T>>;
+export declare function splitBy<T>(this: Array<T>, splitter: (value: T, index: number, array: Array<T>) => boolean): Array<Array<T>>;
+export declare function groupBy<T, K>(this: Array<T>, keySelector: (value: T, index: number, array: Array<T>) => K): Map<K, Array<T>>;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = exports.splitBy = exports.unique = exports.forceArray = exports.take = void 0;
+function take(count) {
+    return this.slice(0, count);
+}
+exports.take = take;
+Array.prototype.take = take;
+function forceArray(arrayable) {
+    return Array.isArray(arrayable) ? arrayable : [arrayable];
+}
+exports.forceArray = forceArray;
+Array.forceArray = forceArray;
+function unique() {
+    return [...new Set(this)];
+}
+exports.unique = unique;
+Array.prototype.unique = unique;
+function splitBy(chunkSizeOrSplitter) {
+    const chunkSize = typeof chunkSizeOrSplitter === 'number' ? chunkSizeOrSplitter : undefined;
+    const splitter = typeof chunkSizeOrSplitter === 'function' ? chunkSizeOrSplitter : undefined;
+    const result = [];
+    if (chunkSize !== undefined) {
+        for (let i = 0; i < this.length; i += chunkSize) {
+            result.push(this.slice(i, i + chunkSize));
+        }
+    }
+    else if (splitter !== undefined) {
+        const chunk = new Array();
+        for (let i = 0; i < this.length; i++) {
+            const value = this[i];
+            if (splitter(value, i, this)) {
+                if (chunk.length) {
+                    result.push(chunk.splice(0, chunk.length));
+                }
+            }
+            chunk.push(value);
+        }
+        if (chunk.length) {
+            result.push(chunk);
+        }
+    }
+    return result;
+}
+exports.splitBy = splitBy;
+Array.prototype.splitBy = splitBy;
+function groupBy(keySelector) {
+    return this.reduce((map, item, index, array) => {
+        const key = keySelector(item, index, array);
+        const group = map.get(key) ?? new Array();
+        group.push(item);
+        map.set(key, group);
+        return map;
+    }, new Map());
+}
+exports.groupBy = groupBy;
+Array.prototype.groupBy = groupBy;

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

@@ -0,0 +1,24 @@
+export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
+declare global {
+    interface Array<T> {
+        /**
+         * Pushes items to array and returns self with new items
+         * @param items Items to add to array
+         */
+        add(...items: Array<T>): this;
+        /**
+         * Update an item in array
+         * @param old The old value or index to update
+         * @param updated Updated value
+         */
+        update(old: T | number | UpdateFinder<T>, updated: T): T;
+        /**
+         * Removes item from array and returns self without item
+         * @param item Item or index to remove
+         */
+        remove(item: T | number): this;
+    }
+}
+export declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
+export declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
+export declare function remove<T>(this: Array<T>, value: T | number): Array<T>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = exports.update = exports.add = void 0;
+function add(...items) {
+    this.push(...items);
+    return this;
+}
+exports.add = add;
+Array.prototype.add = add;
+function update(old, updated) {
+    const item = typeof old === 'number' ? this[old]
+        : typeof old === 'function' ? this.find(old)
+            : old;
+    if (!item)
+        throw new Error('Old was not found in array!');
+    const index = this.indexOf(item);
+    return this[index] = updated;
+}
+exports.update = update;
+Array.prototype.update = update;
+function remove(value) {
+    const index = typeof value === 'number' ? value : this.indexOf(value);
+    if (index > -1)
+        this.splice(index, 1);
+    return this;
+}
+exports.remove = remove;
+Array.prototype.remove = remove;

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

@@ -0,0 +1,20 @@
+import * as CRUD from './crud.extension';
+export declare const ArrayExtensions: {
+    join<T>(this: T[], separator?: string, endSeparator?: string): string;
+    orderBy<T_1>(this: T_1[], ...comparators: ((a: T_1, b: T_1) => number)[]): T_1[];
+    orderByDescending<T_2>(this: T_2[], ...comparators: ((a: T_2, b: T_2) => number)[]): T_2[];
+    sortByProperty<T_3 extends object>(this: T_3[], ...properties: (keyof T_3)[]): T_3[];
+    random<T_4>(this: T_4[]): T_4;
+    shuffle<T_5>(this: T_5[]): T_5[];
+    randomWithPercentages<T_6>(items: [item: T_6, weight: number][]): T_6;
+    nth<T_7, U>(this: T_7[], every: number, callback: (item: T_7, index: number, collection: T_7[], self: T_7[]) => U): U[];
+    add<T_8>(this: T_8[], ...items: T_8[]): T_8[];
+    update<T_9>(this: T_9[], old: number | T_9 | CRUD.UpdateFinder<T_9>, updated: T_9): T_9;
+    remove<T_10>(this: T_10[], value: number | T_10): T_10[];
+    take<T_11>(this: T_11[], count: number): T_11[];
+    forceArray<T_12>(arrayable: import("../..").Arrayable<T_12>): T_12[];
+    unique<T_13>(this: T_13[]): T_13[];
+    splitBy<T_14>(this: T_14[], chunkSize: number): T_14[][];
+    splitBy<T_15>(this: T_15[], splitter: (value: T_15, index: number, array: T_15[]) => boolean): T_15[][];
+    groupBy<T_16, K>(this: T_16[], keySelector: (value: T_16, index: number, array: T_16[]) => K): Map<K, T_16[]>;
+};

package/dist/Extensions/Array/index.js

@@ -0,0 +1,40 @@
+"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.ArrayExtensions = void 0;
+const Array = __importStar(require("./array.extension"));
+const CRUD = __importStar(require("./crud.extension"));
+const Loop = __importStar(require("./loop.extension"));
+const Random = __importStar(require("./random.extension"));
+const Sort = __importStar(require("./sort.extension"));
+const String = __importStar(require("./string.extension"));
+exports.ArrayExtensions = {
+    ...Array,
+    ...CRUD,
+    ...Loop,
+    ...Random,
+    ...Sort,
+    ...String,
+};

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

@@ -0,0 +1,18 @@
+declare global {
+    interface Array<T> {
+        /**
+         * For every x in array, execute callback
+         * @param every i.e every 2nd item in array
+         * @param callback Function to execute
+         * @returns Array of results
+         */
+        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
+    }
+}
+/**
+ * For every x in array, execute callback
+ * @param every i.e every 2nd item in array
+ * @param callback Function to execute. This includes a collection of items prior to last callback run
+ * @returns Array of results
+ */
+export declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nth = void 0;
+/**
+ * For every x in array, execute callback
+ * @param every i.e every 2nd item in array
+ * @param callback Function to execute. This includes a collection of items prior to last callback run
+ * @returns Array of results
+ */
+function nth(every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if ((i + 1) % every === 0) {
+            result.push(callback(this[i], i, collection, this));
+            collection = new Array();
+        }
+    }
+    return result;
+}
+exports.nth = nth;
+Array.prototype.nth = nth;

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

@@ -0,0 +1,23 @@
+declare global {
+    interface Array<T> {
+        /**
+         * Returns a random element from the array.
+         * @returns A random element from the array.
+         */
+        random(): T;
+        /**
+         * Returns a new array with the elements of the original array in random order.
+         * @returns A new array with the elements shuffled.
+         */
+        shuffle(): Array<T>;
+        /**
+         * Selects a random item from an array based on specified weights.
+         * @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;
+    }
+}
+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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomWithPercentages = exports.shuffle = exports.random = void 0;
+function random() {
+    const randomIndex = Math.floor(Math.random() * this.length);
+    return this[randomIndex];
+}
+exports.random = random;
+Array.prototype.random = random;
+function shuffle() {
+    return this.sort(() => Math.random() - 0.5);
+}
+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/sort.extension.d.ts

@@ -0,0 +1,27 @@
+type Comparator<T> = (a: T, b: T) => number;
+declare global {
+    interface Array<T> {
+        /**
+         * Sorts the array using multiple comparators.
+         * @param comparators Functions to compare elements.
+         * @returns Sorted array.
+         */
+        orderBy(...comparators: Array<Comparator<T>>): Array<T>;
+        /**
+         * Sorts the array using multiple comparators in descending order.
+         * @param comparators Functions to compare elements.
+         * @returns Sorted array in descending order.
+         */
+        orderByDescending(...comparators: Array<Comparator<T>>): Array<T>;
+        /**
+         * Sorts the array by specified properties.
+         * @param properties Properties to sort by.
+         * @returns Sorted array.
+         */
+        sortByProperty(...properties: Array<keyof T>): Array<T>;
+    }
+}
+export declare function orderBy<T>(this: Array<T>, ...comparators: Array<Comparator<T>>): Array<T>;
+export declare function orderByDescending<T>(this: Array<T>, ...comparators: Array<Comparator<T>>): Array<T>;
+export declare function sortByProperty<T extends object>(this: Array<T>, ...properties: Array<keyof T>): Array<T>;
+export {};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByProperty = exports.orderByDescending = exports.orderBy = void 0;
+function orderBy(...comparators) {
+    return this.sort((a, b) => {
+        for (const comparator of comparators) {
+            const result = comparator(a, b);
+            if (result !== 0)
+                return result;
+        }
+        return 0;
+    });
+}
+exports.orderBy = orderBy;
+Array.prototype.orderBy = orderBy;
+function orderByDescending(...comparators) {
+    return this.orderBy(...comparators).reverse();
+}
+exports.orderByDescending = orderByDescending;
+Array.prototype.orderByDescending = orderByDescending;
+function sortByProperty(...properties) {
+    return this.orderBy(...properties.map(property => (a, b) => {
+        if (a[property] < b[property])
+            return -1;
+        if (a[property] > b[property])
+            return 1;
+        return 0;
+    }));
+}
+exports.sortByProperty = sortByProperty;
+Array.prototype.sortByProperty = sortByProperty;

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

@@ -0,0 +1,13 @@
+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.
+         * @returns A string with the joined elements.
+         */
+        join(args?: Array<string | undefined>, separator?: string, endSeparator?: string): string;
+    }
+}
+export declare function join<T>(this: Array<T>, separator?: string, endSeparator?: string): string;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = void 0;
+function join(separator = ',', endSeparator = '&') {
+    const validArgs = this.filter(arg => !Object.isNullOrUndefined(arg) && arg !== '');
+    if (!validArgs.length)
+        return '';
+    if (validArgs.length === 1)
+        return validArgs.shift().toString();
+    const lastArg = validArgs.pop();
+    const combinedArgs = validArgs.join(separator);
+    return `${combinedArgs}${endSeparator ? ` ${endSeparator} ` : ''}${lastArg}`;
+}
+exports.join = join;