danholibraryjs 1.11.0 → 2.0.1

package/src/Extensions/Object/booleans.extension.ts

@@ -0,0 +1,46 @@
+declare global {
+  interface ObjectConstructor {
+    /**
+     * Returns true if objects are equal by comparing their properties and values recursively. Does not compare functions.
+     * @param a First object
+     * @param b Second object
+     * @returns true if objects are equal, false otherwise
+     */
+    areEqual<T extends object | null>(a?: T, b?: T): boolean;
+
+    /**
+     * Returns true if object is empty
+     * @param obj Object to check
+     */
+    isNullOrUndefined(obj: any): obj is null | undefined;
+  }
+}
+
+export function areEqual<T extends object | null>(a?: T, b?: T): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (isNullOrUndefined(a) && isNullOrUndefined(b)) return true;
+
+  const keysA = Object.keys(a ?? {});
+  const keysB = Object.keys(b ?? {});
+  if (keysA.length !== keysB.length) return false;
+
+  try {
+    const jsonA = JSON.stringify(a);
+    const jsonB = JSON.stringify(b);
+    if (jsonA === jsonB) return true;
+  } catch {
+    for (const key of keysA) {
+      if (!keysB.includes(key)) return false;
+      if (!areEqual((a as any)[key], (b as any)[key])) return false;
+    }
+  }
+
+  return true;
+}
+Object.areEqual = areEqual;
+
+export function isNullOrUndefined(obj: any): obj is null | undefined {
+  return obj === null || obj === undefined;
+}
+Object.isNullOrUndefined = isNullOrUndefined;

package/src/Extensions/Object/extracts.extension.ts

@@ -0,0 +1,102 @@
+declare global {
+  interface ObjectConstructor {
+    /**
+     * Get a copy of object without specified properties or partial versions.
+     * @param from Object to extract properties from
+     * @param props Properties to extract/Omit
+     */
+    omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+
+    /**
+     * Get a copy of object with only specified properties or partial versions.
+     * @param from Object to extract properties from
+     * @param props Properties to extract/Pick
+     */
+    pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+
+    /**
+     * Receive an object with properties that are not in union of source and target objects
+     * @param source Source object 
+     * @param target Target object 
+     * @param exclude Properties to exclude from difference
+     * @returns Object with properties that are not in union of source and target objects, excluding specified properties
+     */
+    difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+
+    /**
+     * Deeply combines objects, with later objects in parameters taking precedence over earlier ones. Does not combine arrays.
+     * @param objects Objects to combine
+     * @returns Combined object
+     */
+    combine<T extends Record<string, any | undefined>>(...objects: Array<Partial<T> | undefined>): T;
+  }
+}
+
+
+export function omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props> {
+  return props.reduce((result, prop) => {
+    if (typeof prop === "object") {
+      const keys = Object.keysOf(prop);
+      keys.forEach(key => delete (result as Partial<From>)[key]);
+    } else {
+      delete (result as Partial<From>)[prop];
+    }
+
+    return result;
+  }, { ...from } as Omit<From, Props>);
+}
+Object.omit = omit;
+
+export function pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props> {
+  return props.reduce((result, prop) => {
+    if (typeof prop === "object") {
+      const keys = Object.keysOf(prop);
+      keys.forEach(key => (result as Partial<From>)[key] = from[key]);
+    } else {
+      (result as Partial<From>)[prop] = from[prop];
+    }
+    return result;
+  }, {} as Pick<From, Props>);
+}
+Object.pick = pick;
+
+export function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T> {
+  const diffKeys = new Set([...Object.keysOf(source), ...Object.keysOf(target)]);
+  exclude?.forEach(key => diffKeys.delete(key));
+
+  return [...diffKeys.values()].reduce((acc, key, i, arr) => {
+    const sourceValue = JSON.stringify(source[key]);
+    const targetValue = JSON.stringify(target[key]);
+    if (sourceValue !== targetValue) acc[key] = target[key];
+    return acc;
+  }, {} as T);
+}
+Object.difference = difference;
+
+type Combinable<T extends Record<string, any>> = {
+  [key in keyof T]?: T[key] extends Record<string, any> ? Combinable<T[key]> : T[key];
+};
+
+export function combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<T> | undefined>): T {
+  return objects.reduce((acc: T, obj) => {
+    if (!obj) return acc;
+
+    for (const key in obj) {
+      if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        try {
+          acc[key] = combine(acc[key] as T, obj[key] as T) as any;
+        } catch (err) {
+          const error = err as Error;
+          if (error.message.includes('Maximum call stack size exceeded')) {
+            acc[key] = obj[key] as any;
+          } else throw err;
+        }
+      } else if (obj[key] !== undefined && obj[key] !== null && obj[key] !== '') {
+        // @ts-ignore
+        (acc[key] as Combinable<T>) = obj[key];
+      }
+    }
+    return acc;
+  }, {} as T) as T;
+}
+Object.combine = combine;

package/src/Extensions/Object/index.ts

@@ -1,82 +1,4 @@
-import { ValueOf } from "../../Types";
-import { Properties, properties } from "./properties";
-
-declare global {
-    interface ObjectConstructor {
-        /**
-         * Destructures object into array of [property, value]
-         * @param from Object to destruct
-         */
-        array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>
-
-        /**
-         * Omits properties from object, but for some reason the correct term is "extract"
-         * @param from Object to extract properties from
-         * @param props Properties to extract/Omit
-         */
-        extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>
-
-        /**
-         * Pick properties from object, but for some reason the correct term is "exclude"
-         * @param from Object to exclude properties from
-         * @param props Properties to exclude/pick
-         */
-        exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>
-
-        /**
-         * Returns true if object is empty
-         * @param obj Object to check
-         */
-        isNullOrUndefined(obj: any): obj is null | undefined
-
-        /**
-         * Destructures object into array of property keys
-         * @param from Object to destruct
-         */
-        keysOf<From extends {} = {}>(from: From): Array<keyof From>
-
-        omit<From extends {}, Exclude extends keyof From>(from: From, ...exclude: Exclude[]): Omit<From, Exclude>;
-
-        properties: Properties
-    }
-}
-
-function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
-    return Object.keysOf(from).map(prop => [prop, from[prop]]) as Array<[keyof From, ValueOf<From>]>;
-}
-Object.array = array;
-
-function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props> {
-    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From> 
-    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
-    _props.forEach(prop => delete from[prop as keyof From]);
-    return from;
-}
-Object.extract = extract;
-
-function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props> {
-    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From>
-    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
-    return Object.keysOf(from).reduce((result, prop) => {
-        if (_props.includes(prop as Props)) delete result[prop];
-        return result;
-    }, from);
-}
-Object.exclude = exclude;
-
-function isNullOrUndefined(obj: any): obj is null | undefined {
-    return obj === null || obj === undefined;
-}
-Object.isNullOrUndefined = isNullOrUndefined;
-
-function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From> {
-    return Object.keys(from) as Array<keyof From>;
-}
-Object.keysOf = keysOf;
-
-Object.properties = properties;
-
-export const ObjectExtensions = {
-    properties,
-    array, extract, exclude, isNullOrUndefined, keysOf, 
-};
+export * from './arrays.extension';
+export * from './booleans.extension';
+export * from './extracts.extension';
+export * from './properties.extension';

package/src/Extensions/Object/properties.extension.ts

@@ -0,0 +1,59 @@
+import { PropertiesWith, If } from '../../Types';
+import { convertCase } from '../String/case.extension';
+
+type PrimitiveMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  undefined: undefined;
+  null: null;
+  object: object;
+  function: Function;
+  any: any;
+  Date: Date;
+  RegExp: RegExp;
+  Promise: Promise<any>;
+  Array: Array<any>;
+  Map: Map<any, any>;
+  Set: Set<any>;
+};
+
+/**
+ * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
+ *  source: Source,
+ *  allowFunctions: AllowFunctions = false
+ * ): Object with properties from source that matches primitive type
+ */
+export type Properties = {
+  [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]:
+  <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) =>
+    If<AllowFunctions,
+      PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
+      PropertiesWith<PrimitiveMap[Key], Source>
+    >
+};
+
+declare global {
+  interface ObjectConstructor {
+    properties: Properties;
+  }
+}
+
+export const properties: Properties = [
+  'string', 'number', 'boolean', 'undefined', 'null',
+  'object', 'function', 'any',
+  'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+  result[`get${convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
+    return Object.keysOf<Source>(source).reduce((result, key) => {
+      if ((source[key] as any).constructor.name === primitive ||
+        (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
+        result[key] = source[key];
+      }
+      return result;
+    }, {} as any);
+  };
+  return result;
+}, {} as Properties);
+
+Object.properties = properties;

package/src/Extensions/Object/properties.ts

@@ -1,22 +1,22 @@
 import { PropertiesWith, If } from '../../Types';
-import { StringExtensions } from '../String';
+import { convertCase } from '../String/case.extension';
 
 type PrimitiveMap = {
-    string: string;
-    number: number;
-    boolean: boolean;
-    undefined: undefined;
-    null: null;
-    object: object;
-    function: Function;
-    any: any;
-    Date: Date;
-    RegExp: RegExp;
-    Promise: Promise<any>;
-    Array: Array<any>;
-    Map: Map<any, any>;
-    Set: Set<any>;
-}
+  string: string;
+  number: number;
+  boolean: boolean;
+  undefined: undefined;
+  null: null;
+  object: object;
+  function: Function;
+  any: any;
+  Date: Date;
+  RegExp: RegExp;
+  Promise: Promise<any>;
+  Array: Array<any>;
+  Map: Map<any, any>;
+  Set: Set<any>;
+};
 
 /**
  * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
@@ -25,27 +25,27 @@ type PrimitiveMap = {
  * ): Object with properties from source that matches primitive type
  */
 export type Properties = {
-    [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]: 
-        <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) => 
-            If<AllowFunctions,
-                PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
-                PropertiesWith<PrimitiveMap[Key], Source>
-            >
-}
+  [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]:
+  <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) =>
+    If<AllowFunctions,
+      PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
+      PropertiesWith<PrimitiveMap[Key], Source>
+    >
+};
 
 export const properties: Properties = [
-    'string', 'number', 'boolean', 'undefined', 'null', 
-    'object', 'function', 'any', 
-    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+  'string', 'number', 'boolean', 'undefined', 'null',
+  'object', 'function', 'any',
+  'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
 ].reduce((result, primitive) => {
-    result[`get${StringExtensions.toPascalCase.bind(primitive)()}s` as keyof Properties] = function<Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
-        return Object.keysOf<Source>(source).reduce((result, key) => {
-            if ((source[key] as any).constructor.name === primitive || 
-                (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
-                result[key] = source[key];
-            }
-            return result;
-        }, {} as any);
-    }
-    return result;
+  result[`get${convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
+    return Object.keysOf<Source>(source).reduce((result, key) => {
+      if ((source[key] as any).constructor.name === primitive ||
+        (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
+        result[key] = source[key];
+      }
+      return result;
+    }, {} as any);
+  };
+  return result;
 }, {} as Properties);

package/src/Extensions/String/case.extension.ts

@@ -0,0 +1,95 @@
+export type Case = 'camel' | 'pascal' | 'snake' | 'kebab' | 'lower' | 'upper';
+
+declare global {
+  interface String {
+    /**
+     * Converts string from one case to another.
+     * @param from Case to convert from
+     * @param to Cases to convert to, in order. If multiple cases are provided, they will be applied in order
+     */
+    convertCase<To extends Array<Case>, Return extends To extends [...Array<Case>, infer To] ? To : Case>(
+      from: Case,
+      ...to: To
+    ): (
+      Return extends 'upper' ? Uppercase<string>
+      : Return extends 'lower' ? Lowercase<string>
+      : Return extends 'pascal' ? Capitalize<string>
+      : Return extends 'camel' ? Uncapitalize<string>
+      : string
+    );
+  }
+}
+
+const caseMap: Record<Case, Record<Case, (str: string) => string>> = {
+  camel: {
+    camel: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    pascal: (str: string) => str[0].toUpperCase() + str.replace(/([A-Z])/g, (match) => ` ${match}`).slice(1),
+    snake: (str: string) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+    kebab: (str: string) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+  },
+  pascal: {
+    pascal: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str[0].toLowerCase() + str.slice(1),
+    snake: (str: string) => str.replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`),
+    kebab: (str: string) => str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`),
+  },
+  snake: {
+    snake: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str.replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+    pascal: (str: string) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(_\w)/g, (match) => match[1].toUpperCase()),
+    kebab: (str: string) => str.replace(/_/g, '-'),
+  },
+  kebab: {
+    kebab: (str) => str,
+    lower: (str: string) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str.replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+    pascal: (str: string) => str[0].toUpperCase() + str.substring(1, str.length).replace(/(-\w)/g, (match) => match[1].toUpperCase()),
+    snake: (str: string) => str.replace(/-/g, '_'),
+  },
+
+  lower: {
+    lower: (str) => str.toLowerCase(),
+    upper: (str: string) => str.toUpperCase(),
+
+    camel: (str: string) => str,
+    pascal: (str: string) => str[0].toUpperCase() + str.slice(1),
+    snake: (str: string) => str,
+    kebab: (str: string) => str,
+  },
+
+  upper: {
+    upper: (str) => str.toUpperCase(),
+    camel: (str: string) => str[0].toLowerCase() + str.slice(1),
+    pascal: (str: string) => str[0].toUpperCase() + str.toLowerCase().slice(1),
+    snake: (str: string) => str.replace(/ /g, '_'),
+    kebab: (str: string) => str.replace(/ /g, '-'),
+    lower: (str: string) => str.toLowerCase(),
+  }
+};
+
+export const convertCase = <
+  TValue extends string,
+  To extends Array<Case>,
+  Return extends To extends [...Array<Case>, infer To] ? To : Case
+>(
+  value: TValue,
+  from: Case,
+  ...to: To
+): (
+    Return extends 'upper' ? Uppercase<TValue>
+    : Return extends 'lower' ? Lowercase<TValue>
+    : Return extends 'pascal' ? Capitalize<TValue>
+    : Return extends 'camel' ? Uncapitalize<TValue>
+    : string
+  ) => to.reduce((str, toCase) => caseMap[from][toCase](str), value as string) as any;

package/src/Extensions/String/index.ts

@@ -0,0 +1 @@
+export * from './case.extension';

package/src/Extensions/index.ts

@@ -1,24 +1,6 @@
-
 export * from './Array';
-export * from './Document';
+export * from './Function';
 export * from './Map';
+export * from './Number';
 export * from './Object';
-export * from './String';
-
-declare global {
-    interface BooleanConstructor {
-        /**
-         * Parses string to boolean. Will only return true if value === "true" otherwise false
-         */
-        parseBoolean(value: string): boolean
-    }
-}
-
-function parseBoolean(value: string) {
-    return value === "true";
-};
-Boolean.parseBoolean = parseBoolean;
-
-export const BooleanExtensions = {
-    parseBoolean
-};
+export * from './String';

package/src/Interfaces/ElementOptions.ts

@@ -1,9 +1,9 @@
-import { Arrayable, IElement } from "../Types"
+import { Arrayable, IElement } from "../Types";
 
 type Events = Record<
-    `on${Capitalize<keyof HTMLElementEventMap>}`,
-    (event: Event) => void
->
+  `on${Capitalize<keyof HTMLElementEventMap>}`,
+  (event: Event) => void
+>;
 
 /**
  * Construction options when creating an HTML element using:
@@ -12,10 +12,10 @@ type Events = Record<
  * @borrows Arrayable
  */
 export type ElementOptions = Partial<
-    Events & Record<string, any> & {
+  Events & Record<string, any> & {
     id: string,
     className: Arrayable<string>;
     children: Arrayable<IElement>;
-    dataset: Record<string, string>
-}>
+    dataset: Record<string, string>;
+  }>;
 export default ElementOptions;

package/src/Interfaces/IReplacement.ts

@@ -7,7 +7,7 @@ import { StringRegex } from "../Types";
  * @borrows StringRegex
 */
 export interface IReplacement {
-    replacer?: StringRegex,
-    replacement?: string
+  replacer?: StringRegex,
+  replacement?: string;
 }
 export default IReplacement;

package/src/Types/Able.ts

@@ -0,0 +1,22 @@
+/**
+ * Item is function or T
+ */
+export type Functionable<T, Args extends any[] = []> = T | ((...args: Args) => T);
+
+/**
+ * Item is Promise<T> or T
+ */
+export type Promisable<T> = T | Promise<T>;
+
+/**
+ * Item is T or null
+ */
+export type Nullable<T> = T | null;
+
+/**
+ * Item cannot be null or undefined
+ */
+export type NonNullable<T> =
+  T extends null ? never :
+  T extends undefined ? never :
+  T;

package/src/Types/Array.ts

@@ -0,0 +1,7 @@
+/**
+ * Item is single or multiple
+ */
+export type Arrayable<T> = T | Array<T>;
+
+export type SingleArrayable<T> = T | [T];
+export type TFromArray<T> = T extends Array<infer U> ? U : never;

package/src/Types/C#.ts

@@ -0,0 +1,9 @@
+/**
+ * C# Guid representation
+ */
+export type Guid = string;
+
+/**
+ * C# TimeSpan representation from JSON
+ */
+export type TimeSpanType = string;

package/src/Types/Date.ts

@@ -1,4 +1,4 @@
-export type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+export type LongMonth = 'January' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
 export type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
 export type Month = LongMonth | ShortMonth;
 

package/src/Types/Events.ts

@@ -1,15 +1,15 @@
 /**
- * Default eventhandler mapper. Object with properties that are arrays
+ * Default event-handler mapper. Object with properties that are arrays
  */
- export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
 
- /**
-  * Eventhandler type for:
-  * @see EventCollection
-  * @borrows BaseEvent
-  */
- export type EventHandler<
-     Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
-     Event extends keyof Events = keyof Events,
-     ReturnType = any
- > = (...args: Events[Event]) => ReturnType;
+/**
+ * Event-handler type for:
+ * @see EventCollection
+ * @borrows BaseEvent
+ */
+export type EventHandler<
+  Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
+  Event extends keyof Events = keyof Events,
+  ReturnType = any
+> = (...args: Events[Event]) => ReturnType;

package/src/Types/Function.ts

@@ -0,0 +1,10 @@
+export type NewReturnType<
+  Function extends (...args: any[]) => any,
+  NewReturnType extends any
+> = (...args: Parameters<Function>) => NewReturnType;
+
+export type PromisedReturn<
+  Function extends (...args: any[]) => any,
+> = NewReturnType<Function, Promise<ReturnType<Function>>>;
+
+export type NoFunctions<T> = { [K in keyof T]: T[K] extends Function ? never : T[K]; };

package/src/Types/Object.ts

@@ -0,0 +1,4 @@
+/**
+ * Return types of T
+ */
+export type ValueOf<T> = T[keyof T];