danholibraryjs 1.11.0 → 2.0.1

package/src/Types/PropertiesWith.ts

@@ -2,13 +2,44 @@
  * Filters all properties from From that has the return type of Type
  */
 export 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]
+};
 export default PropertiesWith;
 
 /**
  * Fitlers all properties from From that don't have the return type of Type
  */
 export 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]
+};
+
+/**
+ * GetRepeatedKeys<[
+ *  { username: string, password: string },
+ *  { username: number, email: string },
+ * ]> // { username: string | number }
+ */
+export type GetRepeatedKeys<Types extends Array<any>> = (
+  Types extends [infer First, infer Second, ...infer Rest]
+    ? First extends object
+      ? Second extends object
+        ? {
+          [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key]
+        } & GetRepeatedKeys<Rest>
+        : {}
+      : {}
+    : {}
+);
+
+/**
+ * Situation: Model = Character | Artifact | Domain
+ * Type must include generic type T, which is the Model type
+ * Type must also include generic type TProps, which is the properties of the Model type. Selected properties of TProps must extract the types of Model whose properties has been selected.
+ * 
+ * Example:
+ * type Model = Character | Artifact | Domain
+ * Properties<Model, 'name' | 'rarity'>
+ * 
+ * Result: Character | Artifact, because only Character and Artifact have 'name' and 'rarity' properties
+ */
+export type ModelWithProps<T, TProps extends (keyof T | string)> = T extends Record<TProps, any> ? T : never;

package/src/Types/String.ts

@@ -0,0 +1 @@
+export type Autocomplete<T> = T | (string & {});

package/src/Types/TransformTypes.ts

@@ -2,27 +2,35 @@
  * Converts Start types to Switch types in From type
  */
 export 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
  */
-export type TransformTypes<From, BaseType, NewType> = Record<keyof { 
-    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key 
-}, NewType>
+export type TransformTypes<From, BaseType, NewType> = Record<keyof {
+  [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key
+}, NewType>;
 
 //Returns From with properties switched from BaseType to NewType
 // export type TransformTypes<From, BaseType, NewType> = TransformType<From, BaseType[keyof BaseType], NewType>;
 
 export type Json<T> = {
-    [Key in keyof T]: T[Key] extends object 
-        ? Json<T[Key]> 
-        : T[Key] extends Array<infer U> 
-            ? Array<Json<U>> 
-            : T[Key] extends number | string | boolean | null
-                ? T[Key]
-                : string
-}
+  [Key in keyof T]: T[Key] extends object
+    ? Json<T[Key]>
+    : T[Key] extends Array<infer U>
+      ? Array<Json<U>>
+      : T[Key] extends number | string | boolean | null
+        ? T[Key]
+        : string
+};
+
+
+/**
+ * Type's properties are ReturnType
+ */
+export type AllPropsAre<ReturnType> = {
+  [key: string]: ReturnType;
+};
 
 export default TransformTypes;

package/src/Types/index.ts

@@ -1,46 +1,14 @@
+export * from './Able';
+export * from './Array';
 export * from './BetterTypes';
+export * from './C#';
 export * from './Date';
 export * from './Events';
+export * from './Function';
 export * from './TransformTypes';
+export * from './Object';
 export * from './PropertiesWith';
-
-/**
- * Item is single or multiple
- */
-export type Arrayable<T> = T | Array<T>;
-
-/**
- * Item is function or T
- */
-export type Functionable<T> = T | (() => 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;
-
-/**
- * C# Guid representation
- */
-export type Guid = string;
-
-/**
- * C# TimeSpan representation from JSON
- */
-export type TimeSpanType = string;
+export * from './String';
 
 /**
  * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
@@ -51,39 +19,9 @@ export type TimeSpanType = string;
  */
 export type IElement = HTMLElement | string;
 
-/**
- * Return types of T
- */
-export type ValueOf<T> = T[keyof T];
-
-/**
- * Type's properties are ReturnType
- */
-export type AllPropsAre<ReturnType> = {
-    [key: string]: ReturnType
-}
-
 /**
  * string or RegExp.. pretty self-explanatory
  */
 export type StringRegex = string | RegExp;
 
-export type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;
-
-/**
- * GetRepeatedKeys<[
- *  { username: string, password: string },
- *  { username: number, email: string },
- * ]> // { username: string | number }
- */
-export type GetRepeatedKeys<Types extends Array<any>> = (
-    Types extends [infer First, infer Second, ...infer Rest]
-        ? First extends object
-            ? Second extends object
-                ? {
-                    [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key]
-                } & GetRepeatedKeys<Rest>
-            : {}
-        : {}
-    : {}
-);
+export type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;

package/src/Utils/{ApiUtil → ApiUtils}/ApiTypes.ts

@@ -1,4 +1,4 @@
-// An ApiEndpoint paramter can be either a string or undefined
+// An ApiEndpoint parameter can be either a string or undefined
 export type TParam = string | undefined;
 
 // All possible HTTP methods
@@ -6,6 +6,7 @@ export type HttpMethods =
   | 'GET'
   | 'POST'
   | 'PUT'
+  | 'PATCH'
   | 'DELETE';
 
 // Options for the Request function

package/src/Utils/{ApiUtil → ApiUtils}/index.ts

@@ -1,7 +1,7 @@
 import { ApiUtilOptions, RequestOptions } from "./ApiTypes";
 import { Request } from "./RequestUtil";
 
-export class ApiUtil<ApiEndpoints extends string> {
+export class ApiUtils<ApiEndpoints extends string> {
   protected __baseEndpointDev: string;
   protected __baseEndpoint?: string;
   protected __log: boolean;

package/src/Utils/ColorUtils.ts

@@ -0,0 +1,102 @@
+export type RGB = [number, number, number];
+export type Hex = `#${string}`;
+export type ColorType = 'hex' | 'rgb' | 'hsl';
+
+
+export function convert(value: RGB, to: Exclude<ColorType, 'rgb'>): string;
+export function convert(value: string, from: Exclude<ColorType, 'rgb'>, to: 'rgb'): RGB;
+export function convert(value: string | RGB, fromOrTo: ColorType, to?: ColorType): string | RGB {
+  const from = typeof value === 'string' ? fromOrTo : 'rgb';
+  const target = typeof value === 'string' ? to : fromOrTo;
+
+  if (from === target) return value as string;
+
+  switch (from) {
+    case 'hsl': {
+      switch (target) {
+        case 'hex': return hslToHex(value as string);
+        case 'rgb': return hexToRgb(hslToHex(value as string)) as RGB;
+      }
+    }
+    case 'rgb': {
+      switch (target) {
+        case 'hex': return hslToHex(rgbToHsl(value as RGB))
+        case 'hsl': return rgbToHsl(value as RGB);
+      }
+    }
+    case 'hex': {
+      switch (target) {
+        case 'rgb': return hexToRgb(value as Hex) as RGB;
+        case 'hsl': return rgbToHsl(hexToRgb(value as Hex));
+      }
+    }
+    default: return value;
+  }
+}
+
+export function generateRandomColor(): Hex {
+  return `#${Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0')}`;
+}
+
+export const ColorUtils = {
+  convert,
+  generateRandomColor
+};
+
+export default ColorUtils;
+
+function hslToHex(value?: string): Hex {
+  if (!value) return "#000000";
+
+  const match = value.match(/hsl\((\d+), (\d+)%, (\d+)%\)/);
+  if (!match) return value as Hex;
+
+  let [_, h, s, l] = match.map(Number);
+  l /= 100;
+  const a = s * Math.min(l, 1 - l) / 100;
+  const format = (value: number) => {
+    const k = (value + h / 30) % 12;
+    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+    return Math.round(255 * color).toString(16).padStart(2, '0');
+  };
+  return `#${format(0)}${format(8)}${format(4)}`;
+}
+
+function hexToRgb(hex: Hex): RGB {
+  if (!hex) return [0, 0, 0];
+
+  const match = hex.match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+  if (!match) return [0, 0, 0];
+
+  let colorString = match[0];
+
+  if (match[0].length === 3) colorString = colorString.split('').map(char => char + char).join('');
+
+  const integer = parseInt(colorString, 16);
+  const r = (integer >> 16) & 0xFF;
+  const g = (integer >> 8) & 0xFF;
+  const b = integer & 0xFF;
+
+  return [r, g, b];
+}
+
+function rgbToHsl(rgb: RGB): string {
+  let [r, g, b] = rgb.map(x => x / 255);
+  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  let h = 0, s = 0, l = (max + min) / 2;
+
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+    switch (max) {
+      case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+      case g: h = (b - r) / d + 2; break;
+      case b: h = (r - g) / d + 4; break;
+    }
+
+    h /= 6;
+  }
+
+  return `hsl(${Math.round(h * 360)}, ${Math.round(s * 100)}%, ${Math.round(l * 100)}%)`;
+}

package/src/Utils/{FormUtil.ts → FormUtils.ts}

@@ -15,14 +15,14 @@ export function serializeForm<T extends object>(form: HTMLFormElement, log = fal
 
       const name = element.getAttribute('name');
       if (!name) {
-        console.error('[DanhoLibraryRJS] [FormUtil]: name attribute is required', { element });
+        console.error('[DanhoLibraryJS] [FormUtil]: name attribute is required', { element });
         throw new Error('name attribute is required');
       }
 
       const value = element.value;
       if (value === null) console.warn(`${name}.value returned null`, { element });
 
-      if (log) console.log(`[DanhoLibraryRJS] [FormUtil]`, { name, value });
+      if (log) console.log(`[DanhoLibraryJS] [FormUtil]`, { name, value });
       acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
     }
 

package/src/Utils/NumberUtils.ts

@@ -0,0 +1,3 @@
+export function between(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}

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

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

package/src/index.ts

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