danholibraryjs 2.0.0 → 2.0.2

package/src/Extensions/Array/index.ts

@@ -1,15 +1,6 @@
-import * as Array from './array.extension';
-import * as CRUD from './crud.extension';
-import * as Loop from './loop.extension';
-import * as Random from './random.extension';
-import * as Sort from './sort.extension';
-import * as String from './string.extension';
-
-export const ArrayExtensions = {
-  ...Array,
-  ...CRUD,
-  ...Loop,
-  ...Random,
-  ...Sort,
-  ...String,
-};
+export * from './array.extension';
+export * from './crud.extension';
+export * from './loop.extension';
+export * from './random.extension';
+export * from './sort.extension';
+export * from './string.extension';

package/src/Extensions/Array/random.extension.ts

@@ -17,7 +17,7 @@ declare global {
      * @param items An array of tuples where each tuple contains an item and its corresponding weight.
      * @returns A randomly selected item based on the provided weights.
      */
-    randomWithPercentages(items: [item: T, weight: number][]): T;
+    randomWithPercentages(items: Array<[item: T, weight: number]>): T;
   }
 }
 
@@ -30,27 +30,4 @@ Array.prototype.random = random;
 export function shuffle<T>(this: Array<T>): Array<T> {
   return this.sort(() => Math.random() - 0.5);
 }
-Array.prototype.shuffle = shuffle;
-
-export function randomWithPercentages<T>(items: [item: T, weight: number][]): T {
-  if (items.length === 0) throw new Error('Items array cannot be empty');
-
-  // Calculate total weight in case weights don't sum to 100
-  const totalWeight = items.reduce((sum, [, weight]) => sum + weight, 0);
-  if (totalWeight === 0) throw new Error('Total weight must be greater than zero');
-
-  // Generate random number between 0 and totalWeight
-  const random = Math.random() * totalWeight;
-
-  // Find the item that corresponds to this random value
-  let currentWeight = 0;
-  for (const [item, weight] of items) {
-    currentWeight += weight;
-    if (random <= currentWeight) {
-      return item;
-    }
-  }
-
-  throw new Error('Unable to select an item based on weights');
-}
-Array.prototype.randomWithPercentages = randomWithPercentages;
+Array.prototype.shuffle = shuffle;

package/src/Extensions/Array/string.extension.ts

@@ -2,12 +2,11 @@ declare global {
   interface Array<T> {
     /**
      * Joins the elements of the array into a string, with optional custom separators.
-     * @param args An array of strings or undefined values to be used as separators between elements.
-     * @param separator The default separator to use between elements if args is not provided or undefined.
-     * @param endSeparator The separator to use before the last element.
+     * @param separator The default separator to use between elements. Defaults to ','.
+     * @param endSeparator The separator to use before the last element. Default is '&'.
      * @returns A string with the joined elements.
      */
-    join(args?: Array<string | undefined>, separator?: string, endSeparator?: string): string;
+    join(separator?: string, endSeparator?: string): string;
   }
 }
 

package/src/Extensions/Number.ts

@@ -5,13 +5,13 @@ type Separators = {
 
 declare global {
   interface Number {
-    toSeparationString(separators: Partial<Separators>): string;
+    toSeparationString(separators?: Partial<Separators>): string;
     toRomanNumeral(): string;
   }
 }
 
-export function toSeparationString(this: number, separators: Partial<Separators>): string {
-  const { thousand = '.', decimal = '.' } = separators;
+export function toSeparationString(this: number, separators?: Partial<Separators>): string {
+  const { thousand = '.', decimal = '.' } = separators || {};
   const [integerPart, decimalPart] = this.toString().split('.');
   const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousand);
   return decimalPart ? `${formattedInteger}${decimal}${decimalPart}` : formattedInteger;

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

@@ -7,6 +7,18 @@ declare global {
      * @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>>;
 
     /**
      * Destructures object into array of property keys
@@ -16,8 +28,17 @@ declare global {
   }
 }
 
-export function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
-  return Object.entries(from) as Array<[keyof From, ValueOf<From>]>;
+export function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+export function array<From extends {} = {}>(this: object, from: From, selector: 'keys'): Array<keyof From>;
+export function array<From extends {} = {}>(this: object, from: From, selector: 'values'): Array<ValueOf<From>>;
+export function array<From extends {} = {}>(this: object, from: From, selector?: 'keys' | 'values') {
+  const entries = Object.entries(from) as Array<[keyof From, ValueOf<From>]>;
+  
+  switch (selector) {
+    case 'keys': return entries.map(([key]) => key);
+    case 'values': return entries.map(([, value]) => value);
+    default: return entries;
+  }
 }
 Object.array = array;
 

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

@@ -15,20 +15,20 @@ declare global {
     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
+     * Returns the difference between two objects (properties where values differ)
      * @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
+     * @param exclude Properties to exclude from comparison
+     * @returns Object with properties where values differ between source and target, excluding specified properties
      */
-    difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+    difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Partial<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;
+    combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<T> | undefined>): T;
   }
 }
 
@@ -60,16 +60,21 @@ export function pick<From extends {}, Props extends keyof From>(from: From, ...p
 }
 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));
+export function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Partial<T> {
+  const excludeSet = new Set(exclude);
+  const allKeys = new Set([...Object.keysOf(source), ...Object.keysOf(target)]);
 
-  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 [...allKeys].reduce((acc, key) => {
+    if (excludeSet.has(key)) return acc;
+    
+    const sourceValue = (source as any)[key];
+    const targetValue = (target as any)[key];
+    
+    if (JSON.stringify(sourceValue) !== JSON.stringify(targetValue)) {
+      acc[key] = targetValue;
+    }
     return acc;
-  }, {} as T);
+  }, {} as any) as Partial<T>;
 }
 Object.difference = difference;
 

package/src/Extensions/Object/index.ts

@@ -1,11 +1,4 @@
-import * as Array from './arrays.extension';
-import * as Booleans from './booleans.extension';
-import * as Extracts from './extracts.extension';
-import * as Properties from './properties.extension';
-
-export const ObjectExtensions = {
-  ...Array,
-  ...Booleans,
-  ...Extracts,
-  ...Properties
-};
+export * from './arrays.extension';
+export * from './booleans.extension';
+export * from './extracts.extension';
+export * from './properties.extension';

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

@@ -1,4 +1,37 @@
-import { Properties, properties } from "./properties";
+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 {
@@ -6,6 +39,21 @@ declare global {
   }
 }
 
-
+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/String/index.ts

@@ -1,5 +1,2 @@
-import * as Case from './case.extension';
-
-export const StringUtils = {
-  ...Case,
-}
+export * from './case.extension';
+export * from './string.extension';

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

@@ -0,0 +1,11 @@
+declare global {
+  interface String {
+    truncate(length: number, ellipsis?: string): string;
+  }
+}
+
+export function truncate(this: string, length: number, ellipsis: string = "..."): string {
+  if (this.length <= length) return this;
+  return this.slice(0, length - ellipsis.length) + ellipsis;
+}
+String.prototype.truncate = truncate;

package/src/Extensions/index.ts

@@ -1,6 +1,6 @@
 export * from './Array';
-export * from './Document';
+export * from './Function';
 export * from './Map';
-export * from './Object';
 export * from './Number';
+export * from './Object';
 export * from './String';

package/src/Types/Able.ts

@@ -6,7 +6,7 @@ export type Functionable<T, Args extends any[] = []> = T | ((...args: Args) => T
 /**
  * Item is Promise<T> or T
  */
-export type Promisable<T> = T | Promise<T>;
+export type Promiseable<T> = T | Promise<T>;
 
 /**
  * Item is T or null

package/src/Utils/NumberUtils.ts

@@ -1,3 +1,30 @@
 export function between(min: number, max: number): number {
   return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export function randomWithPercentages<T>(items: [item: T, weight: number][]): T {
+  if (items.length === 0) throw new Error('Items array cannot be empty');
+
+  // Calculate total weight in case weights don't sum to 100
+  const totalWeight = items.reduce((sum, [, weight]) => sum + weight, 0);
+  if (totalWeight === 0) throw new Error('Total weight must be greater than zero');
+
+  // Generate random number between 0 and totalWeight
+  const random = Math.random() * totalWeight;
+
+  // Find the item that corresponds to this random value
+  let currentWeight = 0;
+  for (const [item, weight] of items) {
+    currentWeight += weight;
+    if (random <= currentWeight) {
+      return item;
+    }
+  }
+
+  throw new Error('Unable to select an item based on weights');
+}
+
+export const NumberUtils = {
+  between,
+  randomWithPercentages,
 }

package/src/Utils/StringUtils.ts

@@ -41,4 +41,10 @@ export function pluralize(countable: number | ArrayLike<any> | Map<any, any>, si
   if (count === 1) return singular;
   if (plural) return plural;
   return `${singular}s`;
-}
+}
+
+export const StringUtils = {
+  classNames,
+  randomId,
+  pluralize
+};

package/src/Utils/TimeUtils/index.ts

@@ -1,9 +1,11 @@
 import * as Debounce from './debounce.util';
 import * as Functions from './functions.util';
 import * as Throttle from './throttle.util';
+import * as StringUtils from './string.util';
 
 export const TimeUtils = {
   ...Functions,
   ...Debounce,
   ...Throttle,
+  ...StringUtils,
 };

package/src/Utils/TimeUtils/string.util.ts

@@ -0,0 +1,13 @@
+export function ensureStartZero(num: number): string {
+  return num < 10 ? `0${num}` : num.toString();
+}
+
+export function get12HourFormat(hour: number): string {
+  if (hour === 0) return '12am';
+  if (hour > 12) return `${hour - 12}pm`;
+  return `${hour}am`;
+}
+
+export function get24HourFormat(hour: number): string {
+  return ensureStartZero(hour);
+}

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './Classes';
 export * from './Extensions';
-export * from './Functions';
 export * from './Interfaces';
-export * from './Types';
+export * from './Types';
+export * from './Utils';

package/dist/Extensions/Array.d.ts

@@ -1,52 +0,0 @@
-export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
-declare global {
-    interface Array<T> {
-        /**
-         * Pushes items to array and returns self with new items
-         * @param items Items to add to array
-         */
-        add(...items: Array<T>): this;
-        /**
-         * Update an item in array
-         * @param old The old value or index to update
-         * @param updated Updated value
-         */
-        update(old: T | number | UpdateFinder<T>, updated: T): T;
-        /**
-         * Removes item from array and returns self without item
-         * @param item Item or index to remove
-         */
-        remove(item: T | number): this;
-        /**
-         * Returns a random element from array
-         */
-        random(): T;
-        /**
-         * Returns item matching index. If negative number, subtracts number from length
-         * @param i Index of item
-         */
-        index(i: number): T;
-        /**
-         * For every x in array, execute callback
-         * @param every i.e every 2nd item in array
-         * @param callback Function to execute
-         * @returns Array of results
-         */
-        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
-    }
-}
-declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
-declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
-declare function remove<T>(this: Array<T>, value: T | number): Array<T>;
-declare function random<T>(this: Array<T>): T;
-declare function index<T>(this: Array<T>, i: number): T;
-declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;
-export declare const ArrayExtensions: {
-    add: typeof add;
-    update: typeof update;
-    remove: typeof remove;
-    random: typeof random;
-    index: typeof index;
-    nth: typeof nth;
-};
-export {};

package/dist/Extensions/Array.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = void 0;
-function add(...items) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.add = add;
-function update(old, updated) {
-    const item = typeof old === 'number' ? this[old]
-        : typeof old === 'function' ? this.find(old)
-            : old;
-    if (!item)
-        throw new Error('Old was not found in array!');
-    const index = this.indexOf(item);
-    return this[index] = updated;
-}
-Array.prototype.update = update;
-function remove(value) {
-    const index = typeof value === 'number' ? value : this.indexOf(value);
-    if (index > -1)
-        this.splice(index, 1);
-    return this;
-}
-Array.prototype.remove = remove;
-function random() {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-Array.prototype.random = random;
-function index(i) {
-    return this[i < 0 ? this.length + i : i];
-}
-Array.prototype.index = index;
-function nth(every, callback) {
-    const result = new Array();
-    let collection = new Array();
-    for (let i = 0; i < this.length; i++) {
-        collection.push(this[i]);
-        if (i % every === 0) {
-            result.push(callback(this[i], i, collection, this));
-            collection = new Array();
-        }
-    }
-    return result;
-}
-Array.prototype.nth = nth;
-exports.ArrayExtensions = {
-    add, update, remove,
-    random, index, nth
-};

package/dist/Extensions/Document.d.ts

@@ -1,27 +0,0 @@
-import { IElement } from "../Types";
-declare global {
-    interface Document {
-        /**
-         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
-         * @param tagName HTMLElement tag name
-         * @param options Construction options, instead of assigning values after construction
-         * @param children Child elements
-         */
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
-}
-declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
-export declare const DocumentExtensions: {
-    createElement: typeof createElement;
-    createElementFromString: typeof createElementFromString;
-};
-export {};

package/dist/Extensions/Document.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentExtensions = void 0;
-function createElement(tagName, options, ...children) {
-    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
-    children ??= typeof options === 'string' ? [options] : [];
-    typeof options === 'string' && children.unshift(options);
-    if (!children.length)
-        return element;
-    else if (typeof children === 'string')
-        element.innerHTML = children;
-    else if (children instanceof Array)
-        children.forEach(child => (typeof child === 'string' ?
-            element.innerHTML += child :
-            element.appendChild(child)));
-    else
-        element.appendChild(children);
-    return element;
-}
-Document.prototype.createProperElement = createElement;
-function createElementFromString(html, tag) {
-    if (!html.startsWith(`<${tag}`))
-        html = `<${tag}>${html}</${tag}>`;
-    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
-}
-Document.prototype.createElementFromString = createElementFromString;
-HTMLCollection.prototype.array = function () {
-    return Array.from(this);
-};
-exports.DocumentExtensions = {
-    createElement, createElementFromString
-};

package/dist/Extensions/String.d.ts

@@ -1,36 +0,0 @@
-import IReplacement from "../Interfaces/IReplacement";
-declare global {
-    interface String {
-        /**
-         * Uppercases first letter of string
-         */
-        toPascalCase(): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toSnakeCase(replaceOptions?: IReplacement): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toKebabCase(replaceOptions?: IReplacement): string;
-        /**
-         * String.substring but accepting negative numbers to cut from length
-         * @param start Start of string. 0 indexed, if negative number, subtracts number from length
-         * @param end End of string. 0 indexed, if negative number, substracts number from length
-         */
-        clip(start: number, end?: number): string;
-    }
-}
-declare function toPascalCase(this: string): string;
-declare function toSnakeCase(this: string, replaceOptions: IReplacement): string;
-declare function toKebabCase(this: string, replaceOptions: IReplacement): string;
-declare function clip(this: string, start: number, end?: number): string;
-export declare const StringExtensions: {
-    toPascalCase: typeof toPascalCase;
-    toSnakeCase: typeof toSnakeCase;
-    toKebabCase: typeof toKebabCase;
-    clip: typeof clip;
-};
-export {};

package/dist/Extensions/String.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringExtensions = void 0;
-function toPascalCase() {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-}
-String.prototype.toPascalCase = toPascalCase;
-function spaceReplacer(self, replacer, replacement) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-function toSnakeCase(replaceOptions) {
-    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_');
-}
-String.prototype.toSnakeCase = toSnakeCase;
-function toKebabCase(replaceOptions) {
-    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
-}
-String.prototype.toKebabCase = toKebabCase;
-function clip(start, end) {
-    return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
-}
-String.prototype.clip = clip;
-exports.StringExtensions = {
-    toPascalCase, toSnakeCase, toKebabCase, clip
-};

package/dist/Functions/CopyToClipboard.d.ts

@@ -1,7 +0,0 @@
-/**
- * Copies value to clipboard and alerts a response, if response is defined
- * @param value Value to clipboard
- * @param response Alerts if response is given
- */
-export declare function CopyToClipboard(value: string, response?: string): Promise<void>;
-export default CopyToClipboard;

package/dist/Functions/CopyToClipboard.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopyToClipboard = void 0;
-/**
- * Copies value to clipboard and alerts a response, if response is defined
- * @param value Value to clipboard
- * @param response Alerts if response is given
- */
-async function CopyToClipboard(value, response) {
-    await navigator.clipboard.writeText(value);
-    if (response)
-        alert(response);
-}
-exports.CopyToClipboard = CopyToClipboard;
-exports.default = CopyToClipboard;