danholibraryjs 2.0.2 → 2.0.3

package/docs/Extensions.md

@@ -10,89 +10,89 @@ Extensions add new methods to native JavaScript types and interfaces.
 
 ```ts
 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, index, or finder function to locate item to update
-     * @param updated Updated value
-     */
-    update(old: T | number | ((item: T, index: number, self: Array<T>) => boolean), updated: T): T;
-
-    /**
-     * Removes item from array and returns self without item
-     * @param item Item or index to remove
-     */
-    remove(item: T | number): Array<T>;
-
-    /**
-     * Returns a random element from array
-     */
-    random(): T;
-
-    /**
-     * Shuffles array in random order
-     */
-    shuffle(): Array<T>;
-
-    /**
-     * Returns the first `count` elements from the array
-     * @param count Number of elements to take
-     */
-    take(count: number): Array<T>;
-
-    /**
-     * Returns a new array with 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
-     */
-    splitBy(chunkSizeOrSplitter: number | ((value: T, index: number, array: Array<T>) => boolean)): Array<Array<T>>;
-
-    /**
-     * Groups elements based on a key selector function
-     * @param keySelector A function that selects a key for each element
-     */
-    groupBy<K>(keySelector: (value: T, index: number, array: Array<T>) => K): Map<K, Array<T>>;
-
-    /**
-     * For every nth element in array, execute callback
-     * @param every Execute callback every nth element
-     * @param callback Function to execute
-     */
-    nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>;
-
-    /**
-     * Joins array elements with a separator, and a different separator before the last element
-     * @param separator Separator between elements (default: ',')
-     * @param endSeparator Separator before last element (default: '&')
-     */
-    join(separator?: string, endSeparator?: string): string;
-
-    /**
-     * Orders array by comparators in ascending order
-     * @param comparators Comparison functions
-     */
-    orderBy(...comparators: Array<(a: T, b: T) => number>): Array<T>;
-
-    /**
-     * Orders array by comparators in descending order
-     * @param comparators Comparison functions
-     */
-    orderByDescending(...comparators: Array<(a: T, b: T) => number>): Array<T>;
-
-    /**
-     * Sorts array by object properties
-     * @param properties Properties to sort by
-     */
-    sortByProperty(...properties: Array<keyof T>): 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, index, or finder function to locate item to update
+   * @param updated Updated value
+   */
+  update(old: T | number | ((item: T, index: number, self: Array<T>) => boolean), updated: T): T;
+
+  /**
+   * Removes item from array and returns self without item
+   * @param item Item or index to remove
+   */
+  remove(item: T | number): Array<T>;
+
+  /**
+   * Returns a random element from array
+   */
+  random(): T;
+
+  /**
+   * Shuffles array in random order
+   */
+  shuffle(): Array<T>;
+
+  /**
+   * Returns the first `count` elements from the array
+   * @param count Number of elements to take
+   */
+  take(count: number): Array<T>;
+
+  /**
+   * Returns a new array with 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
+   */
+  splitBy(chunkSizeOrSplitter: number | ((value: T, index: number, array: Array<T>) => boolean)): Array<Array<T>>;
+
+  /**
+   * Groups elements based on a key selector function
+   * @param keySelector A function that selects a key for each element
+   */
+  groupBy<K>(keySelector: (value: T, index: number, array: Array<T>) => K): Map<K, Array<T>>;
+
+  /**
+   * For every nth element in array, execute callback
+   * @param every Execute callback every nth element
+   * @param callback Function to execute
+   */
+  nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>;
+
+  /**
+   * Joins array elements with a separator, and a different separator before the last element
+   * @param separator Separator between elements (default: ',')
+   * @param endSeparator Separator before last element (default: '&')
+   */
+  join(separator?: string, endSeparator?: string): string;
+
+  /**
+   * Orders array by comparators in ascending order
+   * @param comparators Comparison functions
+   */
+  orderBy(...comparators: Array<(a: T, b: T) => number>): Array<T>;
+
+  /**
+   * Orders array by comparators in descending order
+   * @param comparators Comparison functions
+   */
+  orderByDescending(...comparators: Array<(a: T, b: T) => number>): Array<T>;
+
+  /**
+   * Sorts array by object properties
+   * @param properties Properties to sort by
+   */
+  sortByProperty(...properties: Array<keyof T>): Array<T>;
 }
 ```
 
@@ -100,11 +100,11 @@ interface Array<T> {
 
 ```ts
 interface ArrayConstructor {
-    /**
-     * Forces an arrayable object into an array
-     * @param arrayable The value or array to normalize
-     */
-    forceArray<T>(arrayable: T | Array<T>): Array<T>;
+  /**
+   * Forces an arrayable object into an array
+   * @param arrayable The value or array to normalize
+   */
+  forceArray<T>(arrayable: T | Array<T>): Array<T>;
 }
 ```
 
@@ -134,45 +134,45 @@ function forceFunction<T, TArgs extends any[] = any[]>(functionable: T | ((...ar
 
 ```ts
 interface Map<K, V> {
-    /**
-     * Converts map into Array<[Key, Value]>
-     */
-    array(): Array<[K, V]>;
-
-    /**
-     * Maps values into new types
-     * @param callback Mapping function
-     */
-    map<EK, EV>(callback: (value: V, key: K, index: number, self: this) => [EK, EV]): Map<EK, EV>;
-
-    /**
-     * Filters map entries
-     * @param callback Filter function
-     */
-    filter(callback: (value: V, key: K, index: number, self: this) => boolean): Map<K, V>;
-
-    /**
-     * Returns array of keys
-     */
-    keyArr(): Array<K>;
-
-    /**
-     * Returns array of values
-     */
-    valueArr(): Array<V>;
-
-    /**
-     * Finds first entry matching callback
-     * @param callback Find function
-     */
-    find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
-
-    /**
-     * Checks if map includes a value
-     * @param value Value to search for
-     * @param fromIndex Start looking from specific index
-     */
-    includes(value: V, fromIndex?: number): boolean;
+  /**
+   * Converts map into Array<[Key, Value]>
+   */
+  array(): Array<[K, V]>;
+
+  /**
+   * Maps values into new types
+   * @param callback Mapping function
+   */
+  map<EK, EV>(callback: (value: V, key: K, index: number, self: this) => [EK, EV]): Map<EK, EV>;
+
+  /**
+   * Filters map entries
+   * @param callback Filter function
+   */
+  filter(callback: (value: V, key: K, index: number, self: this) => boolean): Map<K, V>;
+
+  /**
+   * Returns array of keys
+   */
+  keyArr(): Array<K>;
+
+  /**
+   * Returns array of values
+   */
+  valueArr(): Array<V>;
+
+  /**
+   * Finds first entry matching callback
+   * @param callback Find function
+   */
+  find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
+
+  /**
+   * Checks if map includes a value
+   * @param value Value to search for
+   * @param fromIndex Start looking from specific index
+   */
+  includes(value: V, fromIndex?: number): boolean;
 }
 ```
 
@@ -180,16 +180,16 @@ interface Map<K, V> {
 
 ```ts
 interface Number {
-    /**
-     * Formats number with thousand and decimal separators
-     * @param separators Custom separators for thousand and decimal (optional)
-     */
-    toSeparationString(separators?: Partial<{ thousand: string; decimal: string }>): string;
-
-    /**
-     * Converts number to Roman numeral (1-3999)
-     */
-    toRomanNumeral(): string;
+  /**
+   * Formats number with thousand and decimal separators
+   * @param separators Custom separators for thousand and decimal (optional)
+   */
+  toSeparationString(separators?: Partial<{ thousand: string; decimal: string }>): string;
+
+  /**
+   * Converts number to Roman numeral (1-3999)
+   */
+  toRomanNumeral(): string;
 }
 ```
 
@@ -199,53 +199,53 @@ interface Number {
 
 ```ts
 interface ObjectConstructor {
-    /**
-     * Destructures object into array of [property, value]
-     * @param from Object to destruct
-     */
-    array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
-    /**
-     * Destructures object into array of property keys or values depending on selector
-     * @param from Object to destruct
-     * @param selector Selects whether to return keys or values
-     */
-    array<From extends {} = {}>(from: From, selector: 'keys'): Array<keyof From>;
-    /**
-     * Destructures object into array of property keys or values depending on selector
-     * @param from Object to destruct
-     * @param selector Selects whether to return keys or values
-     */
-    array<From extends {} = {}>(from: From, selector: 'values'): Array<ValueOf<From>>;
-
-    /**
-     * Returns array of object keys with proper typing
-     * @param from Object to get keys from
-     */
-    keysOf<From = {}>(from: From): Array<keyof From>;
-
-    /**
-     * Object with property filter methods by type
-     * Methods: getStrings, getNumbers, getBooleans, getUndefineds, getNulls,
-     *          getObjects, getFunctions, getAnys, getDates, getRegExps,
-     *          getPromises, getArrays, getMaps, getSets
-     * @example Object.properties.getStrings(obj) // Returns object with only string properties
-     */
-    properties: {
-        getStrings<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getNumbers<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getBooleans<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getUndefineds<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getNulls<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getObjects<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getFunctions<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getAnys<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getDates<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getRegExps<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getPromises<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getArrays<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getMaps<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-        getSets<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
-    };
+  /**
+   * Destructures object into array of [property, value]
+   * @param from Object to destruct
+   */
+  array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+  /**
+   * Destructures object into array of property keys or values depending on selector
+   * @param from Object to destruct
+   * @param selector Selects whether to return keys or values
+   */
+  array<From extends {} = {}>(from: From, selector: 'keys'): Array<keyof From>;
+  /**
+   * Destructures object into array of property keys or values depending on selector
+   * @param from Object to destruct
+   * @param selector Selects whether to return keys or values
+   */
+  array<From extends {} = {}>(from: From, selector: 'values'): Array<ValueOf<From>>;
+
+  /**
+   * Returns array of object keys with proper typing
+   * @param from Object to get keys from
+   */
+  keysOf<From = {}>(from: From): Array<keyof From>;
+
+  /**
+   * Object with property filter methods by type
+   * Methods: getStrings, getNumbers, getBooleans, getUndefineds, getNulls,
+   *          getObjects, getFunctions, getAnys, getDates, getRegExps,
+   *          getPromises, getArrays, getMaps, getSets
+   * @example Object.properties.getStrings(obj) // Returns object with only string properties
+   */
+  properties: {
+      getStrings<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getNumbers<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getBooleans<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getUndefineds<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getNulls<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getObjects<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getFunctions<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getAnys<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getDates<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getRegExps<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getPromises<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getArrays<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getMaps<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+      getSets<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions): Partial<Source>;
+  };
 }
 ```
 
@@ -298,19 +298,19 @@ function isNullOrUndefined(obj: any): obj is null | undefined;
 
 ```ts
 interface String {
-    /**
-     * Converts string from one case to another
-     * @param from Case to convert from ('camel' | 'pascal' | 'snake' | 'kebab' | 'lower' | 'upper')
-     * @param to Cases to convert to, can chain multiple conversions
-     */
-    convertCase(from: Case, ...to: Array<Case>): string;
-
-    /**
-     * Truncates string to specified length with optional ellipsis
-     * @param length Maximum length of string
-     * @param ellipsis String to append if truncated (default: '...')
-     */
-    truncate(length: number, ellipsis?: string): string;
+  /**
+   * Converts string from one case to another
+   * @param from Case to convert from ('camel' | 'pascal' | 'snake' | 'kebab' | 'lower' | 'upper')
+   * @param to Cases to convert to, can chain multiple conversions
+   */
+  convertCase(from: Case, ...to: Array<Case>): string;
+
+  /**
+   * Truncates string to specified length with optional ellipsis
+   * @param length Maximum length of string
+   * @param ellipsis String to append if truncated (default: '...')
+   */
+  truncate(length: number, ellipsis?: string): string;
 }
 ```
 

package/docs/Interfaces.md

@@ -10,16 +10,16 @@
  * @borrows Arrayable
  */
 interface ElementOptions<K extends keyof HTMLElementTagNameMap> {
-    /**css classes to give the element*/
-    classes?: Array<string>;
-    /**attributes to give the element*/
-    attributes?: Array<[string, string]>;
-    /**Children of the element*/
-    children?: Arrayable<IElement>;
-    /**Events for the element to listen to
-     * @use HTMLEvent<Event, RetrunType>(name: Event, handler: (e: Event) => ReturnType)
-    */
-    events?: Array<{ name: string, handler: (e: Event) => any }>
+  /**css classes to give the element*/
+  classes?: Array<string>;
+  /**attributes to give the element*/
+  attributes?: Array<[string, string]>;
+  /**Children of the element*/
+  children?: Arrayable<IElement>;
+  /**Events for the element to listen to
+   * @use HTMLEvent<Event, RetrunType>(name: Event, handler: (e: Event) => ReturnType)
+  */
+  events?: Array<{ name: string, handler: (e: Event) => any }>
 }
 /**
  * Replacement tool for 
@@ -28,7 +28,7 @@ interface ElementOptions<K extends keyof HTMLElementTagNameMap> {
  * @borrows StringRegex
 */
 interface IReplacement {
-    replacer?: StringRegex,
-    replacement?: string
+  replacer?: StringRegex,
+  replacement?: string
 }
 ```

package/docs/Types.md

@@ -164,9 +164,9 @@ type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Typ
  * Event handler type
  */
 type EventHandler<
-    Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
-    Event extends keyof Events = keyof Events,
-    ReturnType = any
+  Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
+  Event extends keyof Events = keyof Events,
+  ReturnType = any
 > = (...args: Events[Event]) => ReturnType;
 ```
 
@@ -177,13 +177,13 @@ type EventHandler<
  * Changes return type of a function
  */
 type NewReturnType<Func extends (...args: any[]) => any, NewReturn> = 
-    Func extends (...args: infer Args) => any ? (...args: Args) => NewReturn : never;
+  Func extends (...args: infer Args) => any ? (...args: Args) => NewReturn : never;
 
 /**
  * Wraps function return type in Promise
  */
 type PromisedReturn<Func extends (...args: any[]) => any> = 
-    Func extends (...args: infer Args) => infer Return ? (...args: Args) => Promise<Return> : never;
+  Func extends (...args: infer Args) => infer Return ? (...args: Args) => Promise<Return> : never;
 
 /**
  * Removes all function properties from type
@@ -198,7 +198,7 @@ type NoFunctions<T> = { [K in keyof T]: T[K] extends Function ? never : T[K] };
  * Type's properties are all ReturnType
  */
 type AllPropsAre<ReturnType> = {
-    [key: string]: ReturnType;
+  [key: string]: ReturnType;
 };
 ```
 
@@ -209,25 +209,25 @@ type AllPropsAre<ReturnType> = {
  * Filters all properties from From that have the return type of Type
  */
 type PropertiesWith<Type, From> = {
-    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key];
+  [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key];
 };
 
 /**
  * Filters all properties from From that don't have the return type of Type
  */
 type PropertiesWithout<Type, From> = {
-    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
+  [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
 };
 
 /**
  * Gets keys that appear in all types in the array
  */
 type GetRepeatedKeys<Types extends Array<any>> = 
-    Types extends [infer First, ...infer Rest]
-        ? Rest extends Array<any>
-            ? keyof First & GetRepeatedKeys<Rest>
-            : keyof First
-        : never;
+  Types extends [infer First, ...infer Rest]
+      ? Rest extends Array<any>
+          ? keyof First & GetRepeatedKeys<Rest>
+          : keyof First
+      : never;
 
 /**
  * Filters types that have specific properties
@@ -251,27 +251,27 @@ type Autocomplete<T> = T | (string & {});
  * Converts Start types to Switch types in From type
  */
 type TransformType<From, Start, Switch> = {
-    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key];
+  [Key in keyof From]: From[Key] extends Start ? Switch : From[Key];
 };
 
 /**
  * Returns object with properties matching BaseType with types of NewType
  */
 type TransformTypes<From, BaseType, NewType> = Record<keyof {
-    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
+  [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
 }, NewType>;
 
 /**
  * Converts object to JSON-serializable type (removes functions, Date -> string, etc.)
  */
 type Json<T> = {
-    [K in keyof T]: T[K] extends Function
-        ? never
-        : T[K] extends Date
-        ? string
-        : T[K] extends object
-        ? Json<T[K]>
-        : T[K];
+  [K in keyof T]: T[K] extends Function
+      ? never
+      : T[K] extends Date
+      ? string
+      : T[K] extends object
+      ? Json<T[K]>
+      : T[K];
 };
 ```
 
@@ -282,5 +282,5 @@ type Json<T> = {
  * Reducer function for Store state updates
  */
 type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = 
-    (state: State, ...args: Types[Action]) => State;
+  (state: State, ...args: Types[Action]) => State;
 ```