@zadytach/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Helzady
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# BlackMagic-Core

package/build/functions/check.d.ts

@@ -0,0 +1,3 @@
+declare function equalsIgnoreCase(text1: string, text2: string): boolean;
+declare function includesIgnoreCase(text: string, query: string): boolean;
+export { equalsIgnoreCase, includesIgnoreCase };

package/build/functions/check.js

@@ -0,0 +1,7 @@
+function equalsIgnoreCase(text1, text2) {
+    return text1.toLowerCase() === text2.toLowerCase();
+}
+function includesIgnoreCase(text, query) {
+    return text.toLowerCase().includes(query.toLowerCase());
+}
+export { equalsIgnoreCase, includesIgnoreCase };

package/build/functions/convert.d.ts

@@ -0,0 +1,3 @@
+declare function hexToRgb(color: string): number;
+declare function rgbToHex(rgb: number, includeHash?: boolean): string;
+export { hexToRgb, rgbToHex };

package/build/functions/convert.js

@@ -0,0 +1,9 @@
+function hexToRgb(color) {
+    return Number.parseInt(color.startsWith("#") ? color.slice(1) : color, 16);
+}
+function rgbToHex(rgb, includeHash = true) {
+    const hexValue = rgb.toString(16);
+    const hexColor = hexValue.padStart(6, "0");
+    return includeHash ? `#${hexColor}` : hexColor;
+}
+export { hexToRgb, rgbToHex };

package/build/functions/date.d.ts

@@ -0,0 +1,2 @@
+declare function createDate(date: Date | string | number): any;
+export { createDate };

package/build/functions/date.js

@@ -0,0 +1,88 @@
+function createDate(date) {
+    const _date = new Date(date ?? Date.now());
+    return Object.assign(_date, {
+        add(unit, value) {
+            switch (unit) {
+                case "days":
+                    _date.setDate(_date.getDate() + value);
+                    break;
+                case "hours":
+                    _date.setHours(_date.getHours() + value);
+                    break;
+                case "minutes":
+                    _date.setMinutes(_date.getMinutes() + value);
+                    break;
+                case "seconds":
+                    _date.setSeconds(_date.getSeconds() + value);
+                    break;
+                case "milliseconds":
+                    _date.setMilliseconds(_date.getMilliseconds() + value);
+                    break;
+                case "months":
+                    _date.setMonth(_date.getMonth() + value);
+                    break;
+                case "years":
+                    _date.setFullYear(_date.getFullYear() + value);
+                    break;
+            }
+            return this;
+        },
+        sub(unit, value) {
+            return this.add(unit, -value);
+        },
+        set(unit, value) {
+            switch (unit) {
+                case "days":
+                    _date.setDate(value);
+                    break;
+                case "hours":
+                    _date.setHours(value);
+                    break;
+                case "minutes":
+                    _date.setMinutes(value);
+                    break;
+                case "seconds":
+                    _date.setSeconds(value);
+                    break;
+                case "milliseconds":
+                    _date.setMilliseconds(value);
+                    break;
+                case "months":
+                    _date.setMonth(value);
+                    break;
+                case "years":
+                    _date.setFullYear(value);
+                    break;
+            }
+            return this;
+        },
+        diff(other, unit = "milliseconds") {
+            const msDiff = Math.abs(_date.getTime() - other.getTime());
+            switch (unit) {
+                case "milliseconds":
+                    return msDiff;
+                case "seconds":
+                    return Math.floor(msDiff / 1e3);
+                case "minutes":
+                    return Math.floor(msDiff / (1e3 * 60));
+                case "hours":
+                    return Math.floor(msDiff / (1e3 * 60 * 60));
+                case "days":
+                    return Math.floor(msDiff / (1e3 * 60 * 60 * 24));
+                case "months": {
+                    const years = _date.getFullYear() - other.getFullYear();
+                    const months = _date.getMonth() - other.getMonth();
+                    return Math.abs(years * 12 + months);
+                }
+                case "years":
+                    return Math.abs(_date.getFullYear() - other.getFullYear());
+                default:
+                    return msDiff;
+            }
+        },
+        clone() {
+            return createDate(_date.getTime());
+        },
+    });
+}
+export { createDate };

package/build/functions/format.d.ts

@@ -0,0 +1,10 @@
+declare function joinBuilder(separator: string, ...text: (string | undefined | null)[]): string;
+declare function notFound(value: any): any;
+declare function brBuilder(...text: (string | undefined | null)[]): string;
+declare function spaceBuilder(...text: (string | undefined | null)[]): string;
+declare function replaceText(text: string, replacements: {
+    [key: string]: string | Function;
+}): string;
+declare function capitalize(word: string, allWords?: boolean): string;
+declare function limitText(text: string, maxLength: number, endText?: string): string;
+export { brBuilder, capitalize, joinBuilder, limitText, notFound, replaceText, spaceBuilder };

package/build/functions/format.js

@@ -0,0 +1,34 @@
+import { isDefined } from '@functions';
+function joinBuilder(separator, ...text) {
+    return text.flat(Infinity).filter(isDefined).filter((bol) => typeof bol === "string").join(separator);
+}
+function notFound(value) {
+    return value !== null ? value : void 0;
+}
+function brBuilder(...text) {
+    return joinBuilder("\n", ...text);
+}
+function spaceBuilder(...text) {
+    return joinBuilder(" ", ...text);
+}
+function replaceText(text, replacements) {
+    const keys = Object.keys(replacements);
+    if (keys.length === 0)
+        return text;
+    keys.sort((a, b) => b.length - a.length);
+    const pattern = new RegExp(keys.map((str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+    return text.replace(pattern, (match) => {
+        const value = replacements[match];
+        return typeof value === "function" ? value(match) : value;
+    });
+}
+function capitalize(word, allWords = false) {
+    word = word.trim();
+    if (!word)
+        return word;
+    return allWords ? word.split(" ").map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join(" ") : word[0].toUpperCase() + word.slice(1).toLowerCase();
+}
+function limitText(text, maxLength, endText = "") {
+    return text.length >= maxLength ? text.slice(0, maxLength) + endText : text;
+}
+export { brBuilder, capitalize, joinBuilder, limitText, notFound, replaceText, spaceBuilder };

package/build/functions/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./check.js";
+export * from "./convert.js";
+export * from "./date.js";
+export * from "./format.js";
+export * from "./validation.js";
+export * from "./with.js";
+export * from "./ms.js";
+export * from "./math.js";
+export * from "./timers.js";
+export * from "./sleep.js";

package/build/functions/index.js

@@ -0,0 +1,10 @@
+export * from "./check.js";
+export * from "./convert.js";
+export * from "./date.js";
+export * from "./format.js";
+export * from "./validation.js";
+export * from "./with.js";
+export * from "./ms.js";
+export * from "./math.js";
+export * from "./timers.js";
+export * from "./sleep.js";

package/build/functions/math.d.ts

@@ -0,0 +1,8 @@
+declare function randomNumber(min: number, max: number): number;
+declare const random: {
+    int(min: number, max: number): number;
+    float(min: number, max: number): number;
+};
+declare function parseIntOrDefault(value: string, defaultValue: number, radix: number): number;
+declare function parseFloatOrDefault(value: string, defaultValue: number): number;
+export { parseFloatOrDefault, parseIntOrDefault, random, randomNumber };

package/build/functions/math.js

@@ -0,0 +1,20 @@
+function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+const random = {
+    int(min, max) {
+        return Math.floor(this.float(min, max + 1));
+    },
+    float(min, max) {
+        return Math.random() * (max - min) + min;
+    }
+};
+function parseIntOrDefault(value, defaultValue, radix) {
+    const parsed = Number.parseInt(value, radix);
+    return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+function parseFloatOrDefault(value, defaultValue) {
+    const parsed = Number.parseFloat(value);
+    return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+export { parseFloatOrDefault, parseIntOrDefault, random, randomNumber };

package/build/functions/ms.d.ts

@@ -0,0 +1,4 @@
+declare const toMs: Function & {
+    [key: string]: any;
+};
+export { toMs };

package/build/functions/ms.js

@@ -0,0 +1,12 @@
+import { withProperties } from '@functions';
+const timeUnits = Object.freeze({
+    seconds: (value) => value * 1e3,
+    minutes: (value) => timeUnits.seconds(value * 60),
+    hours: (value) => timeUnits.minutes(value * 60),
+    days: (value) => timeUnits.hours(value * 24)
+});
+function toMsFunc(value, unit = "seconds") {
+    return timeUnits[unit](value);
+}
+const toMs = withProperties(toMsFunc, timeUnits);
+export { toMs };

package/build/functions/sleep.d.ts

@@ -0,0 +1,4 @@
+declare const sleep: Function & {
+    [key: string]: any;
+};
+export { sleep };

package/build/functions/sleep.js

@@ -0,0 +1,18 @@
+import { setTimeout } from 'node:timers/promises';
+import { withProperties } from '@functions';
+async function baseSleep(time, value) {
+    await setTimeout(time);
+    return typeof value === "function" ? value() : value;
+}
+const sleep = withProperties(baseSleep, {
+    async seconds(time, value) {
+        return sleep(time * 1e3, value);
+    },
+    async minutes(time, value) {
+        return sleep.seconds(time * 60, value);
+    },
+    async hours(time, value) {
+        return sleep.minutes(time * 60, value);
+    }
+});
+export { sleep };

package/build/functions/timers.d.ts

@@ -0,0 +1,25 @@
+declare function createInterval(options: {
+    time: number;
+    run: (stop: () => void) => void;
+    immediately?: boolean;
+}): {
+    timer: NodeJS.Timeout;
+    stop: () => void;
+};
+declare function createTimeout(options: {
+    delay: number;
+    run: () => void;
+}): {
+    timer: NodeJS.Timeout;
+    stop: () => void;
+};
+declare function createLoopInterval(options: {
+    run: (item: any, stop: () => void, lap: number, array: any[]) => void;
+    time: number;
+    array: any[];
+    immediately?: boolean;
+}): {
+    timer: NodeJS.Timeout;
+    stop: () => void;
+};
+export { createInterval, createLoopInterval, createTimeout };

package/build/functions/timers.js

@@ -0,0 +1,33 @@
+function createInterval(options) {
+    const { time, run, immediately } = options;
+    if (immediately)
+        run(() => {
+        });
+    const timer = setInterval(() => {
+        run(() => clearInterval(timer));
+    }, time);
+    return { timer, stop: () => clearInterval(timer) };
+}
+function createTimeout(options) {
+    const { delay, run } = options;
+    const timer = setTimeout(() => run(), delay);
+    return { timer, stop: () => clearTimeout(timer) };
+}
+function createLoopInterval(options) {
+    const { run, time, array, immediately } = options;
+    let lap = 0;
+    let loop = 0;
+    return createInterval({
+        immediately,
+        time,
+        run(stop) {
+            if (loop === array.length) {
+                lap++;
+                loop = 0;
+            }
+            run(array[loop], stop, lap, array);
+            loop++;
+        }
+    });
+}
+export { createInterval, createLoopInterval, createTimeout };

package/build/functions/validation.d.ts

@@ -0,0 +1,6 @@
+declare function isEmail(email: string): boolean;
+declare function isUrl(url: string): boolean;
+declare function isNumeric(text: string): boolean;
+declare function isDefined(value: any): boolean;
+declare function isPromise(value: any): boolean;
+export { isDefined, isEmail, isNumeric, isPromise, isUrl };

package/build/functions/validation.js

@@ -0,0 +1,16 @@
+function isEmail(email) {
+    return new RegExp(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/).test(email);
+}
+function isUrl(url) {
+    return new RegExp(/^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/).test(url);
+}
+function isNumeric(text) {
+    return new RegExp(/^\d+$/).test(text);
+}
+function isDefined(value) {
+    return value !== null && value !== void 0;
+}
+function isPromise(value) {
+    return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+export { isDefined, isEmail, isNumeric, isPromise, isUrl };

package/build/functions/with.d.ts

@@ -0,0 +1,7 @@
+declare function withProperties(fn: Function, props: {
+    [key: string]: any;
+}): Function & {
+    [key: string]: any;
+};
+declare function withTimeout(promise: Promise<any>, time: number, fallback?: any): Promise<any>;
+export { withProperties, withTimeout };

package/build/functions/with.js

@@ -0,0 +1,8 @@
+function withProperties(fn, props) {
+    return Object.assign(fn, props);
+}
+function withTimeout(promise, time, fallback) {
+    const timeout = new Promise((resolve) => setTimeout(() => resolve(fallback ?? null), time));
+    return Promise.race([promise, timeout]);
+}
+export { withProperties, withTimeout };

package/build/index.d.ts

@@ -0,0 +1 @@
+export { equalsIgnoreCase, includesIgnoreCase, hexToRgb, rgbToHex, brBuilder, capitalize, joinBuilder, limitText, notFound, replaceText, spaceBuilder, parseFloatOrDefault, parseIntOrDefault, random, randomNumber, toMs, createInterval, createLoopInterval, createTimeout, isDefined, isEmail, isNumeric, isPromise, isUrl, withProperties, withTimeout, createDate, sleep, } from "@functions";

package/build/index.js

@@ -0,0 +1 @@
+export { equalsIgnoreCase, includesIgnoreCase, hexToRgb, rgbToHex, brBuilder, capitalize, joinBuilder, limitText, notFound, replaceText, spaceBuilder, parseFloatOrDefault, parseIntOrDefault, random, randomNumber, toMs, createInterval, createLoopInterval, createTimeout, isDefined, isEmail, isNumeric, isPromise, isUrl, withProperties, withTimeout, createDate, sleep, } from "@functions";

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@zadytach/core",
+  "version": "1.0.0",
+  "description": "Uma coleção de funções utilitárias simples e leves para tarefas comuns em projetos.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HelzadyDev/BlackMagic-Core.git"
+  },
+  "keywords": [
+    "discord",
+    "discordjs",
+    "typescript"
+  ],
+  "author": {
+    "url": "https://github.com/HelzadyDev",
+    "name": "HelzadyDev"
+  },
+  "license": "ISC",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/HelzadyDev/BlackMagic-Core/issues"
+  },
+  "homepage": "https://github.com/HelzadyDev/BlackMagic-Core#readme",
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3"
+  },
+  "paths": {
+    "@functions": [
+      "./build/functions/index.js"
+    ]
+  }
+}