danholibraryjs 1.11.0 → 2.0.0

package/dist/Utils/StringUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluralize = exports.randomId = exports.classNames = void 0;
+function classNames(...args) {
+    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();
+}
+exports.classNames = classNames;
+function randomId(length = 16) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+exports.randomId = randomId;
+function pluralize(countable, singular, plural) {
+    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`;
+}
+exports.pluralize = pluralize;

package/dist/Utils/TimeUtils/debounce.util.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 declare function debounce<T>(debounceId: string, callback: () => T, delay: number, signal?: AbortSignal): Promise<T>;
+/**
+ * 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 declare function wrapInDebounce<T>(callback: (...args: T[]) => void, delay: number): {
+    debounced: (...args: T[]) => Promise<void>;
+    controller: AbortController;
+    abort: () => void;
+};

package/dist/Utils/TimeUtils/debounce.util.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInDebounce = exports.debounce = void 0;
+const DebounceManager = {
+    timers: new Map(),
+    abortListeners: new Map(),
+};
+/**
+ * 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
+ */
+function debounce(debounceId, callback, delay, signal) {
+    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((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;
+}
+exports.debounce = debounce;
+/**
+ * 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
+ */
+function wrapInDebounce(callback, delay) {
+    const controller = new AbortController();
+    return {
+        debounced: (...args) => debounce(Symbol().toString(), () => callback(...args), delay, controller.signal),
+        controller,
+        abort: () => controller.abort(),
+    };
+}
+exports.wrapInDebounce = wrapInDebounce;

package/dist/Utils/TimeUtils/functions.util.d.ts

@@ -0,0 +1,4 @@
+export declare function wait<T>(time: number): Promise<void>;
+export declare function wait<T>(callback: (...args: any[]) => T, time: number): Promise<T>;
+export declare function getUnixTime(date: Date | string): number;
+export declare function getUnixTime(timestamp: number): number;

package/dist/Utils/TimeUtils/functions.util.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnixTime = exports.wait = void 0;
+function wait(callbackOrTime, time) {
+    const callback = typeof callbackOrTime === 'function' ? callbackOrTime : (() => undefined);
+    time ??= callbackOrTime;
+    return new Promise((resolve, reject) => {
+        try {
+            setTimeout(() => resolve(callback()), time);
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+exports.wait = wait;
+function getUnixTime(arg) {
+    const timestamp = typeof arg === 'number' ? arg : new Date(arg).getTime();
+    return Math.floor(timestamp / 1000);
+}
+exports.getUnixTime = getUnixTime;

package/dist/Utils/TimeUtils/index.d.ts

@@ -0,0 +1,15 @@
+export declare const TimeUtils: {
+    throttle<T>(throttleId: string, callback: () => T, cooldown: number): T;
+    wrapInThrottle<T_1>(callback: (...args: T_1[]) => void, cooldown: number): (...args: T_1[]) => void;
+    isThrottleOnCooldown(throttleId: string): boolean;
+    debounce<T_2>(debounceId: string, callback: () => T_2, delay: number, signal?: AbortSignal | undefined): Promise<T_2>;
+    wrapInDebounce<T_3>(callback: (...args: T_3[]) => void, delay: number): {
+        debounced: (...args: T_3[]) => Promise<void>;
+        controller: AbortController;
+        abort: () => void;
+    };
+    wait<T_4>(time: number): Promise<void>;
+    wait<T_5>(callback: (...args: any[]) => T_5, time: number): Promise<T_5>;
+    getUnixTime(date: string | Date): number;
+    getUnixTime(timestamp: number): number;
+};

package/dist/Utils/TimeUtils/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUtils = void 0;
+const Debounce = __importStar(require("./debounce.util"));
+const Functions = __importStar(require("./functions.util"));
+const Throttle = __importStar(require("./throttle.util"));
+exports.TimeUtils = {
+    ...Functions,
+    ...Debounce,
+    ...Throttle,
+};

package/dist/Utils/TimeUtils/throttle.util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function throttle<T>(throttleId: string, callback: () => T, cooldown: number): T;
+/**
+ * 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 declare function wrapInThrottle<T>(callback: (...args: T[]) => void, cooldown: number): (...args: T[]) => void;
+export declare function isThrottleOnCooldown(throttleId: string): boolean;

package/dist/Utils/TimeUtils/throttle.util.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isThrottleOnCooldown = exports.wrapInThrottle = exports.throttle = void 0;
+const ThrottleManager = {
+    cooldowns: new Map(),
+    results: new Map(),
+};
+/**
+ * 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
+ */
+function throttle(throttleId, callback, cooldown) {
+    const { cooldowns, results } = ThrottleManager;
+    const isCooldown = cooldowns.get(throttleId) ?? false;
+    if (isCooldown)
+        return results.get(throttleId);
+    const result = callback();
+    setTimeout(() => {
+        cooldowns.delete(throttleId);
+        results.delete(throttleId);
+    }, cooldown);
+    cooldowns.set(throttleId, true);
+    results.set(throttleId, result);
+    return result;
+}
+exports.throttle = throttle;
+/**
+ * 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
+ */
+function wrapInThrottle(callback, cooldown) {
+    const throttleId = Symbol().toString();
+    return (...args) => throttle(throttleId, () => callback(...args), cooldown);
+}
+exports.wrapInThrottle = wrapInThrottle;
+function isThrottleOnCooldown(throttleId) {
+    return ThrottleManager.cooldowns.get(throttleId) ?? false;
+}
+exports.isThrottleOnCooldown = isThrottleOnCooldown;

package/dist/Utils/index.d.ts

@@ -1,2 +1,7 @@
-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/dist/Utils/index.js

@@ -1,18 +1,23 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ApiUtil"), exports);
-__exportStar(require("./FormUtil"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiUtils"), exports);
+__exportStar(require("./TimeUtils"), exports);
+__exportStar(require("./ColorUtils"), exports);
+__exportStar(require("./FormUtils"), exports);
+__exportStar(require("./NumberUtils"), exports);
+__exportStar(require("./PatcherUtils"), exports);
+__exportStar(require("./StringUtils"), exports);

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,21 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Classes"), exports);
-__exportStar(require("./Extensions"), exports);
-__exportStar(require("./Functions"), exports);
-__exportStar(require("./Interfaces"), exports);
-__exportStar(require("./Types"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Classes"), exports);
+__exportStar(require("./Extensions"), exports);
+__exportStar(require("./Functions"), exports);
+__exportStar(require("./Interfaces"), exports);
+__exportStar(require("./Types"), exports);

package/package.json

@@ -1,7 +1,9 @@
 {
-
   "name": "danholibraryjs",
-  "version": "1.11.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "2.0.0",
   "description": "Library for Javascript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Classes/DanhoLogger.ts

@@ -0,0 +1,78 @@
+type LogOptions = {
+  name?: string;
+  color?: string;
+  preferCollapsed?: boolean;
+}
+
+export default class DanhoLogger {
+  public name: string;
+  public color?: string
+  private _preferCollapsed: boolean;
+  
+  constructor(options: LogOptions = {}) {
+    this.name = options.name || 'DanhoLogger';
+    this.color = options.color;
+    this._preferCollapsed = options.preferCollapsed ?? false;
+  }
+
+  private _getPrefix() {
+    return {
+      prefix: `%c[${this.name}]`,
+      style: `color: ${this.color || 'inherit'}; font-weight: bold;`
+    };
+  }
+  private _log(
+    type: 'log' | 'warn' | 'error',
+    ...args: any[]
+  ) {
+    const { prefix, style } = this._getPrefix();
+    console[type](prefix, style, ...args);
+    return this;
+  }
+
+  public log(...args: any[]) {
+    return this._log('log', ...args);
+  }
+  public warn(...args: any[]) {
+    return this._log('warn', ...args);
+  }
+  public error(...args: any[]) {
+    return this._log('error', ...args);
+  }
+
+  public group(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+
+    const groupMethod = this._preferCollapsed ? console.groupCollapsed : console.group;
+    groupMethod(prefix, style, ...args);
+    
+    return this;
+  }
+  public groupCollapsed(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+    console.groupCollapsed(prefix, style, ...args);
+    return this;
+  }
+  public groupEnd(...args: any[]) {
+    if (args.length) console.log(...args);
+    console.groupEnd();
+    return this;
+  }
+
+  time(label: string) {
+    const { prefix } = this._getPrefix();
+    console.time(`${prefix} ${label}`);
+    return this;
+  }
+  timeEnd(label: string) {
+    const { prefix } = this._getPrefix();
+    console.timeEnd(`${prefix} ${label}`);
+    return this;
+  }
+
+  table(data: any, columns?: string[]) {
+    this.log();
+    console.table(data, columns);
+    return this;
+  }
+}