danholibraryjs 1.10.0 → 2.0.0

package/src/Utils/PatcherUtils.ts

@@ -0,0 +1,111 @@
+type PatchEvent = 'before' | 'instead' | 'after';
+type PatcherReplacement<TTarget extends object, TProperty extends keyof TTarget, TPatchEvent extends PatchEvent> = (
+  TPatchEvent extends 'before' 
+    ? TTarget[TProperty] extends (...args: infer TArgs) => any 
+      ? (...args: TArgs) => TArgs | void
+      : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty] | void
+    : TPatchEvent extends 'instead'
+      ? TTarget[TProperty] extends (...args: infer TArgs) => infer TReturn
+        ? (...args: TArgs) => TReturn
+        : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty]
+    : TTarget[TProperty] extends (...args: infer TArgs) => any
+      ? (...args: TArgs) => void
+      : (previous: TTarget[TProperty], updated: TTarget[TProperty]) => void
+)
+
+type Patch = {
+  event: PatchEvent;
+  replacement: any;
+  original: any;
+  unpatch: () => void;
+}
+const PATCHES = new Map<object, Map<string | symbol | number, Array<Patch>>>();
+
+export function patch<
+  TTarget extends object,
+  TProperty extends keyof TTarget,
+  TPatchEvent extends PatchEvent,
+  TPatchReplacement extends PatcherReplacement<TTarget, TProperty, TPatchEvent>
+>(target: TTarget, property: TProperty, event: TPatchEvent, replacement: TPatchReplacement) {
+  if (!target || !property || !replacement) return;
+  else if (!(property in target)) throw Error(`Property "${String(property)}" does not exist on target`);
+
+  const original = target[property];
+  if (!PATCHES.has(target)) PATCHES.set(target, new Map());
+  const targetPatches = PATCHES.get(target)!;
+
+  if (!targetPatches.has(property)) targetPatches.set(property, []);
+
+  const unpatch = (() => {
+    if (typeof original === 'function') {
+      switch (event) {
+        case 'before': {
+          target[property] = function (...args: any[]) {
+            const updatedArgs = (replacement as any).apply(target, args);
+            return (original as any).apply(target, updatedArgs || args);
+          } as TTarget[TProperty];
+          break;
+        }
+        case 'instead': {
+          target[property] = function (...args: any[]) {
+            return (replacement as any).apply(target, args);
+          } as TTarget[TProperty];
+          break;
+        }
+        case 'after': {
+          target[property] = function (...args: any[]) {
+            const result = (original as any).apply(target, args);
+            (replacement as any).apply(target, args);
+            return result;
+          } as TTarget[TProperty];
+          break;
+        }
+      }
+  
+      return () => target[property] = original;
+    } else {
+      let currentValue = target[property];
+      const propertyDescriptor = Object.getOwnPropertyDescriptor(target, property);
+
+      const valuePatch = (update?: TTarget[TProperty]) => {
+        update ??= currentValue;
+        const result = event !== 'after' ? (replacement as any)(currentValue, update) || currentValue : currentValue;
+        
+        if (event === 'after') (replacement as any)(currentValue, update);
+  
+        return result;
+      }
+  
+      Object.defineProperty(target, property, {
+        get: () => valuePatch(),
+        set: valuePatch,
+      });
+  
+      return () => Object.defineProperty(target, property, propertyDescriptor!);
+    }
+  })();
+
+  targetPatches.get(property)!.push({ event, replacement, original, unpatch });
+  return unpatch;
+}
+
+export function unpatch<
+  TTarget extends object,
+  TProperty extends keyof TTarget
+>(target: TTarget, property: TProperty) {
+  const targetPatches = PATCHES.get(target);
+  if (!targetPatches?.has(property)) return;
+
+  targetPatches.get(property)!.forEach(patch => patch.unpatch());
+  targetPatches.delete(property);
+}
+
+export function unpatchAll() {
+  PATCHES.forEach(properties => {
+    properties.forEach(patches => {
+      patches.forEach(patch => patch.unpatch());
+    });
+  });
+  
+  PATCHES.clear();
+}

package/src/Utils/StringUtils.ts

@@ -0,0 +1,44 @@
+export function classNames(...args: Array<any>): string {
+  return args.reduce((acc, arg) => {
+    if (!arg) return acc;
+
+    switch (typeof arg) {
+      case 'string': {
+        acc += arg; 
+        break;
+      }
+      case 'object': {
+        if (Array.isArray(arg)) {
+          acc += classNames(...arg);
+          break;
+        } else {
+          acc += Object.entries(arg).reduce((objAcc, [key, value]) => objAcc + (value ? key : ''), '');
+          break;
+        }
+      }
+      default: {
+        acc += `${arg}`;
+        break;
+      }
+    }
+
+    return acc + ' ';
+  }, '').trim();
+}
+
+export function randomId(length = 16): string {
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+
+export function pluralize(countable: number | ArrayLike<any> | Map<any, any>, singular: string, plural?: string): string {
+  const count = (
+    typeof countable === 'number' ? countable
+    : countable instanceof Map ? countable.size
+    : countable.length
+  );
+
+  if (count === 1) return singular;
+  if (plural) return plural;
+  return `${singular}s`;
+}

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

@@ -0,0 +1,85 @@
+const DebounceManager = {
+  timers: new Map<string, number>(),
+  abortListeners: new Map<string, () => void>(),
+};
+
+/**
+ * Delay running the callback until delay milliseconds have passed without the function being called again. 
+ * If the function is called again before the delay has passed, the timer resets.
+ * 
+ * @param debounceId A unique identifier for the debounce instance. Call with the same ID to reset the timer.
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @param signal Optional AbortSignal to cancel the debounced operation
+ * @returns A promise that resolves to the result of the callback when it is eventually called, or rejects if aborted
+ */
+export function debounce<T>(debounceId: string, callback: () => T, delay: number, signal?: AbortSignal) {
+  const { timers, abortListeners } = DebounceManager;
+
+  // Clean up existing debounce with the same ID
+  if (timers.has(debounceId)) {
+    clearTimeout(timers.get(debounceId));
+    timers.delete(debounceId);
+
+    const existingListener = abortListeners.get(debounceId);
+    if (existingListener && signal) {
+      signal.removeEventListener('abort', existingListener);
+    }
+    abortListeners.delete(debounceId);
+  }
+
+  const promise = new Promise<T>((resolve, reject) => {
+    // Check if already aborted
+    if (signal?.aborted) {
+      const error = new DOMException('Debounce aborted', 'AbortError');
+      reject(error);
+      return;
+    }
+
+    const timeoutId = setTimeout(() => {
+      timers.delete(debounceId);
+      abortListeners.delete(debounceId);
+
+      try {
+        resolve(callback());
+      } catch (error) {
+        reject(error);
+      }
+    }, delay);
+
+    timers.set(debounceId, timeoutId);
+
+    // Set up abort listener
+    if (signal) {
+      const abortListener = () => {
+        clearTimeout(timeoutId);
+        timers.delete(debounceId);
+        abortListeners.delete(debounceId);
+
+        const error = new DOMException('Debounce aborted', 'AbortError');
+        reject(error);
+      };
+
+      signal.addEventListener('abort', abortListener, { once: true });
+      abortListeners.set(debounceId, abortListener);
+    }
+  });
+
+  return promise;
+}
+
+/**
+ * Wrap a callback in a debounce, allowing it to be called multiple times, but only run after the delay has passed without it being called again
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @returns An object containing the debounced function, an AbortController to cancel operations, and the abort method for convenience
+ */
+export function wrapInDebounce<T>(callback: (...args: T[]) => void, delay: number) {
+  const controller = new AbortController();
+
+  return {
+    debounced: (...args: T[]) => debounce(Symbol().toString(), () => callback(...args), delay, controller.signal),
+    controller,
+    abort: () => controller.abort(),
+  };
+}

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

@@ -0,0 +1,18 @@
+export function wait<T>(time: number): Promise<void>;
+export function wait<T>(callback: (...args: any[]) => T, time: number): Promise<T>;
+export function wait<T>(callbackOrTime: ((...args: any[]) => T) | number, time?: number) {
+  const callback = typeof callbackOrTime === 'function' ? callbackOrTime : (() => undefined);
+  time ??= callbackOrTime as number;
+
+  return new Promise<T>((resolve, reject) => {
+    try { setTimeout(() => resolve(callback() as T), time); }
+    catch (err) { reject(err); }
+  });
+}
+
+export function getUnixTime(date: Date | string): number;
+export function getUnixTime(timestamp: number): number;
+export function getUnixTime(arg: Date | string | number): number {
+  const timestamp = typeof arg === 'number' ? arg : new Date(arg).getTime();
+  return Math.floor(timestamp / 1000);
+}

package/src/Utils/TimeUtils/index.ts

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

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

@@ -0,0 +1,44 @@
+const ThrottleManager = {
+  cooldowns: new Map<string, boolean>(),
+  results: new Map<string, any>(),
+};
+
+/**
+ * Allow callback to be run once every cooldown period, regardless of calls
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback
+ */
+export function throttle<T>(throttleId: string, callback: () => T, cooldown: number) {
+  const { cooldowns, results } = ThrottleManager;
+
+  const isCooldown = cooldowns.get(throttleId) ?? false;
+  if (isCooldown) return results.get(throttleId) as T;
+
+  const result = callback();
+
+  setTimeout(() => {
+    cooldowns.delete(throttleId);
+    results.delete(throttleId);
+  }, cooldown);
+
+  cooldowns.set(throttleId, true);
+  results.set(throttleId, result);
+
+  return result;
+}
+
+/** 
+ * Wrap a callback in a throttle, allowing it to be called multiple times, but only run once every cooldown period
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback that can be called multiple times, but will only run once every cooldown period
+ */
+export function wrapInThrottle<T>(callback: (...args: T[]) => void, cooldown: number) {
+  const throttleId = Symbol().toString();
+  return (...args: T[]) => throttle(throttleId, () => callback(...args), cooldown);
+}
+
+export function isThrottleOnCooldown(throttleId: string) {
+  return ThrottleManager.cooldowns.get(throttleId) ?? false;
+}

package/src/Utils/index.ts

@@ -0,0 +1,8 @@
+export * from './ApiUtils';
+export * from './TimeUtils';
+
+export * from './ColorUtils';
+export * from './FormUtils';
+export * from './NumberUtils';
+export * from './PatcherUtils';
+export * from './StringUtils';

package/src/Extensions/Array.ts

@@ -1,95 +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>
-    }
-}
-
-function add<T>(this: Array<T>, ...items: Array<T>) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.add = add;
-
-function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T) {
-    const item = typeof old === 'number' ? this[old] 
-        : typeof old === 'function' ? this.find(old as UpdateFinder<T>) 
-        : 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<T>(this: Array<T>, value: T | number): Array<T> {
-    const index = typeof value === 'number' ? value : this.indexOf(value);
-    if (index > -1) this.splice(index, 1);
-    return this;
-}
-Array.prototype.remove = remove;
-
-function random<T>(this: Array<T>): T {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-Array.prototype.random = random;
-
-function index<T>(this: Array<T>, i: number): T {
-    return this[i < 0 ? this.length + i : i];
-}
-Array.prototype.index = index;
-
-function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U> {
-    const result = new Array<U>();
-    let collection = new Array<T>();
-
-    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<T>();
-        }
-    }
-
-    return result;
-}
-Array.prototype.nth = nth;
-
-export const ArrayExtensions = {
-    add, update, remove, 
-    random, index, nth
-};

package/src/Extensions/String.ts

@@ -1,54 +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
-    }
-}
-
-function toPascalCase(this: string) {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-}
-String.prototype.toPascalCase = toPascalCase;
-
-function spaceReplacer(self: string, replacer: string | RegExp, replacement: string) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-
-function toSnakeCase(this: string, replaceOptions: IReplacement) {
-    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_')
-}
-String.prototype.toSnakeCase = toSnakeCase;
-
-function toKebabCase(this: string, replaceOptions: IReplacement) {
-    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
-}
-String.prototype.toKebabCase = toKebabCase;
-
-function clip(this: string, start: number, end?: number) {
-    return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
-}
-String.prototype.clip = clip;
-
-export const StringExtensions = {
-    toPascalCase, toSnakeCase, toKebabCase, clip
-};