@futdevpro/fsm-dynamo 1.20.92 → 1.20.93

package/build-esm/_collections/constants/numbers.const.js

@@ -0,0 +1,36 @@
+/**
+ * Multiplier representing one thousand.
+ *
+ * @example
+ * ```ts
+ * const kilobytes = 32 * kilo; // 32000
+ * ```
+ */
+export const kilo = 1000;
+/**
+ * Multiplier representing one million.
+ *
+ * @example
+ * ```ts
+ * const population = 5 * million;
+ * ```
+ */
+export const million = kilo * kilo;
+/**
+ * Multiplier representing one billion.
+ *
+ * @example
+ * ```ts
+ * const views = 2 * billion;
+ * ```
+ */
+export const billion = million * kilo;
+/**
+ * Multiplier representing one trillion.
+ *
+ * @example
+ * ```ts
+ * const nationalDebt = 30 * trillion;
+ * ```
+ */
+export const trillion = billion * kilo;

package/build-esm/_collections/constants/times.const.js

@@ -0,0 +1,38 @@
+/**
+ * Milliseconds in one second.
+ *
+ * @example
+ * ```ts
+ * setTimeout(cb, 5 * second);
+ * ```
+ */
+export const second = 1000;
+/**
+ * Milliseconds in one minute.
+ *
+ * @example
+ * ```ts
+ * const timeout = 2 * minute;
+ * ```
+ */
+export const minute = second * 60;
+/**
+ * Milliseconds in one hour.
+ */
+export const hour = minute * 60;
+/**
+ * Milliseconds in one day.
+ */
+export const day = hour * 24;
+/**
+ * Milliseconds in one week.
+ */
+export const week = day * 7;
+/**
+ * Average milliseconds in one month.
+ */
+export const month = day * 30.4368499;
+/**
+ * Average milliseconds in one year.
+ */
+export const year = day * 365.242199;

package/build-esm/_collections/utils/array.util.js

@@ -0,0 +1,632 @@
+import { DyFM_LogStyle } from '../../_enums/log-style.enum';
+import { DyFM_Log } from './log.util';
+export class DyFM_Array {
+    /**
+     * Asynchronously iterates over an array and applies a function to each element.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves when all elements have been processed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * await DyFM_Array.asyncForEach(list, async (element: number, index?: number, array?: number[]): Promise<void> => {
+     *   console.log(element, index, array);
+     * });
+     * ```
+     */
+    static async asyncForEach(list, func) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncForEach: List is required', [DyFM_LogStyle.red]));
+            return;
+        }
+        for (let i = 0; i < list.length; i++) {
+            await func(list[i], i, list);
+        }
+    }
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning a single result.
+     * @param startData - The initial data to pass to the function.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to the final result.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachReturnToOne(0, list, async (element: number, dataCurrent: number, index?: number, array?: number[]): Promise<number> => {
+     *   return dataCurrent + element;
+     * });
+     * ```
+     */
+    static async asyncForEachReturnToOne(startData, list, func) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToOne: List is required', [DyFM_LogStyle.red]));
+            return startData;
+        }
+        let result = startData;
+        for (let i = 0; i < list.length; i++) {
+            result = await func(list[i], result, i, list);
+        }
+        return result;
+    }
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachReturnToAll(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return element * 2;
+     * });
+     * ```
+     */
+    static async asyncForEachReturnToAll(list, func) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToAll: List is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const resultList = [];
+        for (let i = 0; i < list.length; i++) {
+            resultList.push(await func(list[i], i, list));
+        }
+        return resultList;
+    }
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachAllAtOnce(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return [ element * 2, element * 3 ];
+     * });
+     * console.log(result); // [ [ 2, 3 ], [ 4, 6 ], [ 6, 9 ] ]
+     * ```
+     */
+    static async asyncForEachAllAtOnce(list, func) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncForEachAllAtOnce: List is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        return await Promise.all(list.map(func));
+    }
+    /**
+     * Asynchronously filters an array based on a function.
+     * @param list - The array to filter.
+     * @param filterFunc - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncFilter(list, async (element: number, index?: number, array?: number[]): Promise<boolean> => {
+     *   return element % 2 === 0;
+     * });
+     * console.log(result); // [ 2 ]
+     * ```
+     */
+    static async asyncFilter(list, filterFunc) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncFilter: List is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const resultList = [];
+        for (let i = 0; i < list.length; i++) {
+            if (await filterFunc(list[i], i, list)) {
+                resultList.push(list[i]);
+            }
+        }
+        return resultList;
+    }
+    /**
+     * Asynchronously maps an array based on a function.
+     * @param list - The array to map.
+     * @param mapFunc - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncMap(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return element * 2;
+     * });
+     * console.log(result); // [ 2, 4, 6 ]
+     * ```
+     */
+    static async asyncMap(list, mapFunc) {
+        if (!list) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.asyncMap: List is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const resultList = [];
+        for (let i = 0; i < list.length; i++) {
+            resultList.push(await mapFunc(list[i], i, list));
+        }
+        return resultList;
+    }
+    /**
+     * Returns the last element of an array.
+     * @param array - The array to get the last element from.
+     * @returns The last element of the array, or null if the array is empty.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.last(list);
+     * console.log(result); // 3
+     * ```
+     */
+    static last(array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.last: Array is required', [DyFM_LogStyle.red]));
+            return null;
+        }
+        return array.length ? array[array.length - 1] : null;
+    }
+    /**
+     * Returns true if the string is the last element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the last element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isLast(3, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isLast(element, array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.isLast: Array is required', [DyFM_LogStyle.red]));
+            return false;
+        }
+        return array.indexOf(element) === array.length - 1;
+    }
+    /**
+     * Returns true if the string is the last element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the last element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isLastIndex(2, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isLastIndex(index, array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.isLastIndex: Array is required', [DyFM_LogStyle.red]));
+            return false;
+        }
+        return index === array.length - 1;
+    }
+    /**
+     * Returns true if the string is the first element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the first element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isFirst(1, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isFirst(element, array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.isFirst: Array is required', [DyFM_LogStyle.red]));
+            return false;
+        }
+        return array.indexOf(element) === 0;
+    }
+    /**
+     * Returns the last character of a string.
+     * @param string - The string to get the last character from.
+     * @returns The last character of the string, or null if the string is empty.
+     *
+     * @example
+     * ```ts
+     * const string = 'hello';
+     * const result = DyFM_Array.lastCharacter(string);
+     * console.log(result); // 'o'
+     * ```
+     */
+    static lastCharacter(string) {
+        if (!string) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.lastCharacter: String is required', [DyFM_LogStyle.red]));
+            return null;
+        }
+        return string.length ? string[string.length - 1] : null;
+    }
+    /**
+     * Returns the first element of an array.
+     * @param array - The array to get the first element from.
+     * @returns The first element of the array, or null if the array is empty.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.first(list);
+     * console.log(result); // 1
+     * ```
+     */
+    static first(array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.first: Array is required', [DyFM_LogStyle.red]));
+            return null;
+        }
+        return array.length ? array[0] : null;
+    }
+    /**
+     * Removes an element from an array.
+     * @param array - The array to remove the element from.
+     * @param element - The element to remove from the array.
+     * @returns The array with the element removed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.remove(list, 2);
+     * console.log(result); // [ 1, 3 ]
+     * ```
+     */
+    static remove(array, element) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.remove: Array is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const index = array.indexOf(element);
+        if (-1 < index) {
+            array.splice(index, 1);
+        }
+        return array;
+    }
+    /**
+     * Finds an element in an array and removes it.
+     * @param array - The array to find and remove the element from.
+     * @param func - The function to apply to each element.
+     * @returns The array with the element removed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.findNRemove(list, (element: number, index?: number, array?: number[]): boolean => {
+     *   return element === 2;
+     * });
+     * console.log(result); // [ 1, 3 ]
+     * ```
+     */
+    static findNRemove(array, func) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.findNRemove: Array is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const index = array.findIndex(func);
+        if (-1 < index) {
+            array.splice(index, 1);
+        }
+        return array;
+    }
+    /**
+     * Shuffles an array.
+     * @param array - The array to shuffle.
+     * @returns The shuffled array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.shuffle(list);
+     * console.log(result); // [ 3, 1, 2 ]
+     * ```
+     */
+    static shuffle(array) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.shuffle: Array is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        let currentIndex = array.length;
+        let randomIndex;
+        while (0 < currentIndex) {
+            currentIndex--;
+            randomIndex = Math.floor(Math.random() * (array.length - 1));
+            this.swap(array, currentIndex, randomIndex);
+        }
+        return array;
+    }
+    /**
+     * Pages an array.
+     * @param array - The array to page.
+     * @param pageIndex - The index of the page to return.
+     * @param pageSize - The size of the page.
+     * @returns The page of the array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+     * const result = DyFM_Array.page(list, 0, 2);
+     * console.log(result); // [ 1, 2 ]
+     * ```
+     */
+    static page(array, pageIndex, pageSize) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.page: Array is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        return array.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
+    }
+    /**
+     * Pages an array.
+     * @param array - The array to page.
+     * @param pageIndex - The index of the page to return.
+     * @param pageSize - The size of the page.
+     * @returns The page of the array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+     * const result = DyFM_Array.paged(list, 0, 2);
+     * console.log(result); // { pageIndex: 0, pageSize: 2, total: 8, totalPageCount: 4, items: [ 1, 2 ] }
+     * ```
+     */
+    static paged(array, pageIndex, pageSize) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.paged: Array is required', [DyFM_LogStyle.red]));
+            return {
+                pageIndex: 0,
+                pageSize: 0,
+                total: 0,
+                totalPageCount: 0,
+                items: [],
+            };
+        }
+        return {
+            pageIndex,
+            pageSize,
+            total: array.length,
+            totalPageCount: Math.ceil(array.length / pageSize),
+            items: this.page(array, pageIndex, pageSize),
+        };
+    }
+    /**
+     * Swaps two elements in an array.
+     * @param array - The array to swap the elements in.
+     * @param indexA - The index of the first element to swap.
+     * @param indexB - The index of the second element to swap.
+     * @returns The array with the elements swapped.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.swap(list, 0, 2);
+     * console.log(result); // [ 3, 2, 1 ]
+     * ```
+     */
+    static swap(array, indexA, indexB) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.swap: Array is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        [array[indexA], array[indexB]] = [array[indexB], array[indexA]];
+        return array;
+    }
+    /**
+     * Checks if a string list has multiplications.
+     * @param stringList - The string list to check.
+     * @returns True if the string list has multiplications, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.stringListHasMultiplications(list);
+     * console.log(result); // true
+     * ```
+     */
+    static stringListHasMultiplications(stringList) {
+        if (!stringList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.stringListHasMultiplications: String list is required', [DyFM_LogStyle.red]));
+            return false;
+        }
+        return stringList.some((str, index) => {
+            return stringList.findIndex((strItem) => strItem === str) !== index;
+        });
+    }
+    /**
+     * Filters a string list to remove multiplications.
+     * @param stringList - The string list to filter.
+     * @returns The filtered string list.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.filterStringMultiplications(list);
+     * console.log(result); // [ 'a', 'b', 'c' ]
+     * ```
+     */
+    static filterStringMultiplications(stringList) {
+        if (!stringList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.filterStringMultiplications: String list is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        return stringList.filter((str, index) => {
+            return stringList.findIndex((strItem) => strItem === str) !== index;
+        });
+    }
+    /**
+     * Gathers multiplications from a string list.
+     * @param stringList - The string list to gather multiplications from.
+     * @returns The gathered multiplications.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.gatherStringMultiplications(list);
+     * console.log(result); // [ [ 'a', 'a' ] ]
+     * ```
+     */
+    static gatherStringMultiplications(stringList) {
+        if (!stringList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.gatherStringMultiplications: String list is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const multiplications = [];
+        stringList.forEach((str, index) => {
+            if (multiplications.find((multiplication) => multiplication.includes(str))) {
+                return;
+            }
+            const sameStrings = stringList.filter((strItem) => strItem === str);
+            if (sameStrings.length > 1) {
+                multiplications.push(sameStrings);
+            }
+        });
+        return multiplications;
+    }
+    /**
+     * Checks if a data list has multiplications.
+     * @param dataList - The data list to check.
+     * @param byKey - The key to check for multiplications.
+     * @returns True if the data list has multiplications, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.haveMultiplications(list, '_id');
+     * console.log(result); // true
+     * ```
+     */
+    static haveMultiplications(dataList, byKey = '_id') {
+        if (!dataList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.haveMultiplications: Data list is required', [DyFM_LogStyle.red]));
+            return false;
+        }
+        return dataList.some((data, index) => {
+            return dataList.findIndex((listItem) => listItem[byKey] === data[byKey]) !== index;
+        });
+    }
+    /**
+     * Filters a data list to remove multiplications.
+     * @param dataList - The data list to filter.
+     * @param byKey - The key to filter for multiplications.
+     * @returns The filtered data list.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.filterMultiplications(list, '_id');
+     * console.log(result); // [ { _id: 1, name: 'John' } , { _id: 2, name: 'Jane' } ]
+     * ```
+     */
+    static filterMultiplications(dataList, byKey = '_id') {
+        if (!dataList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.filterMultiplications: Data list is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        return dataList.filter((data, index) => {
+            return dataList.findIndex((listItem) => listItem[byKey] === data[byKey]) !== index;
+        });
+    }
+    /**
+     * Gathers multiplications from a data list.
+     * @param dataList - The data list to gather multiplications from.
+     * @param byKey - The key to gather multiplications from.
+     * @returns The gathered multiplications.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.gatherMultiplications(list, '_id');
+     * console.log(result); // [ [ { _id: 1, name: 'John' }, { _id: 1, name: 'Bob' } ] ]
+     * ```
+     */
+    static gatherMultiplications(dataList, byKey = '_id') {
+        if (!dataList) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.gatherMultiplications: Data list is required', [DyFM_LogStyle.red]));
+            return [];
+        }
+        const multiplications = [];
+        dataList.forEach((data, index) => {
+            if (multiplications.find((multiplication) => multiplication.includes(data))) {
+                return;
+            }
+            const sameData = dataList.filter((listItem) => listItem[byKey] === data[byKey]);
+            if (sameData.length > 1) {
+                multiplications.push(sameData);
+            }
+        });
+        return multiplications;
+    }
+    /**
+     * Finds an element in an array from the end.
+     * @param array - The array to find the element in.
+     * @param func - The function to apply to each element.
+     * @returns The element found, or null if no element is found.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.findFromEnd(list, (element: number, index?: number, array?: number[]): boolean => {
+     *   return element === 2;
+     * });
+     * console.log(result); // 2
+     * ```
+     */
+    static findFromEnd(array, func) {
+        if (!array) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.findFromEnd: Array is required', [DyFM_LogStyle.red]));
+            return null;
+        }
+        for (let i = array.length - 1; i >= 0; i--) {
+            if (func(array[i], i, array)) {
+                return array[i];
+            }
+        }
+        return null;
+    }
+    /**
+     * returns a function that can be used to sort an array of objects
+     * sorts so that the objects that have the value true for the checkFor function are at the beginning of the array
+     * @param checkFor
+     * @returns
+     *
+     */
+    static getSortForTrueFn(checkFor) {
+        return (a, b) => this.sortForTrue(a, b, checkFor);
+    }
+    /**
+     * You might be use getSortForTrueFn instead for a shorter expression
+     *
+     * @param a
+     * @param b
+     * @param check
+     * @returns
+     *
+     * @example
+     * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
+     */
+    static sortForTrue(a, b, check) {
+        if (!check) {
+            console.trace(DyFM_Log.addStyle('DyFM_Array.sortForTrue: Check is required', [DyFM_LogStyle.red]));
+            return 0;
+        }
+        const isA = check(a);
+        if (isA === check(b)) {
+            return 0;
+        }
+        else if (isA) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+}