danholibraryjs 1.11.0 → 2.0.0

package/dist/Classes/store.js

@@ -1,84 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = void 0;
-const Events_1 = require("./Events");
-/**
- * EventEmitter, but it stores state and handles state change with reducers
- *
- * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
- * The ActionType must have properties as strings and values as arrays.
- *
- * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
- * Every state change must return the next state, apart from 'stateChange', which returns void/any
- * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
- * Store.emit should NOT be used, as it doesn't update the Store's state.
- *
- * Reducer functions can be removed using Store.off('action', reducer);
- *
- * @borrows EventEmitter
- * @borrows Arrayable
- *
- * @example ```ts
- * import { Store } from 'danholibraryjs';
- *
- * type Todo = {
- *    id: string,
- *    text: string,
- *    completed: boolean
- * }
- *
- * type TodoActions = {
- *    create: [text: string],
- *    update: [id: string, text: string],
- *    toggleComplete: [id: string, force?: boolean],
- *    delete: [id: string],
- * }
- *
- * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
- *    create: (state, text) => {
- *       return [...state, {
- *          id: Math.random().toString(),
- *          text,
- *          completed: false
- *      }];
- *    },
- *   toggleComplete: (state, id, force) => {
- *      const todo = state.find(todo => todo.id === id);
- *      if (!todo) return state;
- *
- *      return state.map(todo => (
- *          todo.id === id ? {
- *              ...todo,
- *              completed: force === undefined ? !todo.completed : force
- *          } : todo
- *      ));
- *   }
- * ]));
- *
- * store.on('delete', (state, id) => {
- *     return state.filter(todo => todo.id !== id);
- * });
- *
- * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
- *
- * store.dispatch('create', 'Make store!');
- *
- * ```
- */
-class Store extends Events_1.EventEmitter {
-    constructor(state, actions = {}) {
-        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers])));
-        this._state = state;
-    }
-    _state;
-    get state() {
-        return this._state;
-    }
-    dispatch(action, ...args) {
-        const previous = { ...this._state };
-        this._state = super.emit(action, ...args).reduce((state, returned) => ({ ...state, ...returned }), this.state);
-        super.emit('stateChange', ...[previous, this.state]);
-        return this.state;
-    }
-}
-exports.Store = Store;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+const Events_1 = require("./Events");
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+class Store extends Events_1.EventEmitter {
+    constructor(state, actions = {}) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers])));
+        this._state = state;
+    }
+    _state;
+    get state() {
+        return this._state;
+    }
+    dispatch(action, ...args) {
+        const previous = { ...this._state };
+        this._state = super.emit(action, ...args).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+        super.emit('stateChange', ...[previous, this.state]);
+        return this.state;
+    }
+}
+exports.Store = 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;