@futdevpro/fsm-dynamo 1.16.28 → 1.16.29

package/src/_collections/utils/array.util.ts

@@ -1,813 +1,813 @@
-
-import { DyFM_LogStyle } from '../../_enums/log-style.enum';
-import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
-import { DyFM_Log } from './log.util';
-
-/**
- * the return type of the sortForTrue function
- */
-export type DyFM_SortDirection = 0 | 1 | -1
-
-
-export type DyFM_List = DyFM_Array;
-
-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<T>(
-    list: T[], 
-    func: (element: T, index?: number, array?: T[]) => Promise<void>
-  ): Promise<void> {
-    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<T, K>(
-    startData: K,
-    list: T[], 
-    func: (element: T, dataCurrent: K, index?: number, array?: T[]) => Promise<K>
-  ): Promise<K> {
-    if (!list) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToOne: List is required', [ DyFM_LogStyle.red ])
-      );
-      return startData;
-    }
-
-    let result: K = 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<T, K>(
-    list: T[], 
-    func: (element: T, index?: number, array?: T[]) => Promise<K>
-  ): Promise<K[]> {
-    if (!list) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToAll: List is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    const resultList: K[] = [];
-
-    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<T, R>(
-    list: T[], 
-    func: (element: T, index?: number, array?: T[]) => Promise<R>
-  ): Promise<R[]> {
-    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<T>(
-    list: T[], 
-    filterFunc: (element: T, index?: number, array?: T[]) => Promise<boolean>
-  ): Promise<T[]> {
-    if (!list) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.asyncFilter: List is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    const resultList: T[] = [];
-
-    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<T, R>(
-    list: T[], 
-    mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>
-  ): Promise<R[]> {
-    if (!list) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.asyncMap: List is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    const resultList: R[] = [];
-
-    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<T>(array: T[]): T | null {
-    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<T>(element: T, array: T[]): boolean {
-    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<T>(index: number, array: T[]): boolean {
-    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<T>(element: T, array: T[]): boolean {
-    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: string): string | null {
-    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<T>(array: T[]): T | null {
-    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<T>(array: T[], element: T): T[] {
-    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<T>(
-    array: T[], 
-    func: (element: T, index?: number, array?: T[]) => boolean
-  ): T[] {
-    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<T>(array: T[]): T[] {
-    if (!array) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.shuffle: Array is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    let currentIndex = array.length;
-    let randomIndex: number;
-
-    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<T>(array: T[], pageIndex: number, pageSize: number): T[] {
-    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<T>(array: T[], pageIndex: number, pageSize: number): DyFM_Paged<T> {
-    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<T>(array: T[], indexA: number, indexB: number): T[] {
-    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: string[]): boolean {
-    if (!stringList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.stringListHasMultiplications: String list is required', [ DyFM_LogStyle.red ])
-      );
-      return false;
-    }
-
-    return stringList.some((str: string, index: number): boolean => {
-      return stringList.findIndex((strItem: string): boolean => 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: string[]): string[] {
-    if (!stringList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.filterStringMultiplications: String list is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    return stringList.filter((str: string, index: number): boolean => {
-      return stringList.findIndex((strItem: string): boolean => 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: string[]): string[][] {
-    if (!stringList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.gatherStringMultiplications: String list is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    const multiplications: string[][] = [];
-
-    stringList.forEach((str: string, index: number): void => {
-      if (multiplications.find(
-        (multiplication: string[]): boolean => multiplication.includes(str))
-      ) {
-        return;
-      }
-
-      const sameStrings = stringList.filter((strItem: string): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): boolean {
-    if (!dataList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.haveMultiplications: Data list is required', [ DyFM_LogStyle.red ])
-      );
-      return false;
-    }
-
-    return dataList.some((data: T, index: number): boolean => {
-      return dataList.findIndex(
-        (listItem: T): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): T[] {
-    if (!dataList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.filterMultiplications: Data list is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    return dataList.filter((data: T, index: number): boolean => {
-      return dataList.findIndex(
-        (listItem: T): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): T[][] {
-    if (!dataList) {
-      console.trace(
-        DyFM_Log.addStyle('DyFM_Array.gatherMultiplications: Data list is required', [ DyFM_LogStyle.red ])
-      );
-      return [];
-    }
-
-    const multiplications: T[][] = [];
-
-    dataList.forEach((data: T, index: number): void => {
-      if (multiplications.find((multiplication: T[]): boolean => multiplication.includes(data))) {
-        return;
-      }
-
-      const sameData = dataList.filter((listItem: T): boolean => 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<T>(
-    array: T[], 
-    func: (element: T, index?: number, 
-    array?: T[]) => boolean
-  ): T | null {
-    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<T>(
-    checkFor: (a: T) => boolean
-  ): (a: T, b: T) => DyFM_SortDirection {
-    return (a: T, b: T): DyFM_SortDirection => this.sortForTrue<T>(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<T>(
-    a: T, 
-    b: T, 
-    check: (a: T) => boolean
-  ): DyFM_SortDirection {
-    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;
-    }
-  }
-}
-
-
+
+import { DyFM_LogStyle } from '../../_enums/log-style.enum';
+import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
+import { DyFM_Log } from './log.util';
+
+/**
+ * the return type of the sortForTrue function
+ */
+export type DyFM_SortDirection = 0 | 1 | -1
+
+
+export type DyFM_List = DyFM_Array;
+
+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<T>(
+    list: T[], 
+    func: (element: T, index?: number, array?: T[]) => Promise<void>
+  ): Promise<void> {
+    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<T, K>(
+    startData: K,
+    list: T[], 
+    func: (element: T, dataCurrent: K, index?: number, array?: T[]) => Promise<K>
+  ): Promise<K> {
+    if (!list) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToOne: List is required', [ DyFM_LogStyle.red ])
+      );
+      return startData;
+    }
+
+    let result: K = 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<T, K>(
+    list: T[], 
+    func: (element: T, index?: number, array?: T[]) => Promise<K>
+  ): Promise<K[]> {
+    if (!list) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.asyncForEachReturnToAll: List is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    const resultList: K[] = [];
+
+    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<T, R>(
+    list: T[], 
+    func: (element: T, index?: number, array?: T[]) => Promise<R>
+  ): Promise<R[]> {
+    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<T>(
+    list: T[], 
+    filterFunc: (element: T, index?: number, array?: T[]) => Promise<boolean>
+  ): Promise<T[]> {
+    if (!list) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.asyncFilter: List is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    const resultList: T[] = [];
+
+    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<T, R>(
+    list: T[], 
+    mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>
+  ): Promise<R[]> {
+    if (!list) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.asyncMap: List is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    const resultList: R[] = [];
+
+    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<T>(array: T[]): T | null {
+    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<T>(element: T, array: T[]): boolean {
+    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<T>(index: number, array: T[]): boolean {
+    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<T>(element: T, array: T[]): boolean {
+    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: string): string | null {
+    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<T>(array: T[]): T | null {
+    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<T>(array: T[], element: T): T[] {
+    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<T>(
+    array: T[], 
+    func: (element: T, index?: number, array?: T[]) => boolean
+  ): T[] {
+    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<T>(array: T[]): T[] {
+    if (!array) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.shuffle: Array is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    let currentIndex = array.length;
+    let randomIndex: number;
+
+    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<T>(array: T[], pageIndex: number, pageSize: number): T[] {
+    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<T>(array: T[], pageIndex: number, pageSize: number): DyFM_Paged<T> {
+    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<T>(array: T[], indexA: number, indexB: number): T[] {
+    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: string[]): boolean {
+    if (!stringList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.stringListHasMultiplications: String list is required', [ DyFM_LogStyle.red ])
+      );
+      return false;
+    }
+
+    return stringList.some((str: string, index: number): boolean => {
+      return stringList.findIndex((strItem: string): boolean => 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: string[]): string[] {
+    if (!stringList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.filterStringMultiplications: String list is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    return stringList.filter((str: string, index: number): boolean => {
+      return stringList.findIndex((strItem: string): boolean => 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: string[]): string[][] {
+    if (!stringList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.gatherStringMultiplications: String list is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    const multiplications: string[][] = [];
+
+    stringList.forEach((str: string, index: number): void => {
+      if (multiplications.find(
+        (multiplication: string[]): boolean => multiplication.includes(str))
+      ) {
+        return;
+      }
+
+      const sameStrings = stringList.filter((strItem: string): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): boolean {
+    if (!dataList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.haveMultiplications: Data list is required', [ DyFM_LogStyle.red ])
+      );
+      return false;
+    }
+
+    return dataList.some((data: T, index: number): boolean => {
+      return dataList.findIndex(
+        (listItem: T): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): T[] {
+    if (!dataList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.filterMultiplications: Data list is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    return dataList.filter((data: T, index: number): boolean => {
+      return dataList.findIndex(
+        (listItem: T): boolean => 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<T extends object>(dataList: T[], byKey: keyof T = '_id' as keyof T): T[][] {
+    if (!dataList) {
+      console.trace(
+        DyFM_Log.addStyle('DyFM_Array.gatherMultiplications: Data list is required', [ DyFM_LogStyle.red ])
+      );
+      return [];
+    }
+
+    const multiplications: T[][] = [];
+
+    dataList.forEach((data: T, index: number): void => {
+      if (multiplications.find((multiplication: T[]): boolean => multiplication.includes(data))) {
+        return;
+      }
+
+      const sameData = dataList.filter((listItem: T): boolean => 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<T>(
+    array: T[], 
+    func: (element: T, index?: number, 
+    array?: T[]) => boolean
+  ): T | null {
+    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<T>(
+    checkFor: (a: T) => boolean
+  ): (a: T, b: T) => DyFM_SortDirection {
+    return (a: T, b: T): DyFM_SortDirection => this.sortForTrue<T>(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<T>(
+    a: T, 
+    b: T, 
+    check: (a: T) => boolean
+  ): DyFM_SortDirection {
+    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;
+    }
+  }
+}
+
+