@onurege3467/zerohelper/dist/functions/index.js

ZeroHelper is a versatile high-performance utility library and database framework for Node.js, fully written in TypeScript.

"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 () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ai_module = exports.toon_module = exports.worker_module = exports.security_module = exports.logger_module = exports.validation_module = exports.math_module = exports.crypto_module = exports.object_module = exports.array_module = exports.string_module = exports.random_module = exports.date_module = exports.http_module = exports.Logger = void 0;
exports.makeUniqueId = makeUniqueId;
exports.randomArray = randomArray;
exports.randomText = randomText;
exports.randomNumber = randomNumber;
exports.randomEmoji = randomEmoji;
exports.randomHex = randomHex;
exports.randomFloat = randomFloat;
exports.titleCase = titleCase;
exports.generateRandomString = generateRandomString;
exports.generateSlug = generateSlug;
exports.wordCount = wordCount;
exports.shuffleArray = shuffleArray;
exports.flattenArray = flattenArray;
exports.removeFalsyValues = removeFalsyValues;
exports.groupBy = groupBy;
exports.pluck = pluck;
exports.sortBy = sortBy;
exports.filterObjectByKey = filterObjectByKey;
exports.deepMerge = deepMerge;
exports.encryptText = encryptText;
exports.decryptText = decryptText;
exports.hashPassword = hashPassword;
exports.verifyPassword = verifyPassword;
exports.generateJWT = generateJWT;
exports.verifyJWT = verifyJWT;
exports.generateSalt = generateSalt;
exports.validateUUID = validateUUID;
exports.isPasswordStrong = isPasswordStrong;
exports.mean = mean;
exports.median = median;
exports.variance = variance;
exports.standardDeviation = standardDeviation;
exports.sum = sum;
exports.max = max;
exports.min = min;
exports.range = range;
exports.isPrime = isPrime;
exports.factorial = factorial;
exports.combination = combination;
exports.permutation = permutation;
exports.formatDate = formatDate;
exports.dateDifference = dateDifference;
exports.addDays = addDays;
exports.subtractDays = subtractDays;
exports.fetchData = fetchData;
exports.postData = postData;
exports.isEmail = isEmail;
exports.isPhone = isPhone;
exports.isURL = isURL;
exports.sanitizeHTML = sanitizeHTML;
exports.validateCreditCard = validateCreditCard;
exports.validateSchema = validateSchema;
exports.sanitizeInput = sanitizeInput;
exports.createLogger = createLogger;
exports.logInfo = logInfo;
exports.logError = logError;
exports.logWarn = logWarn;
exports.logDebug = logDebug;
const crypto_1 = __importDefault(require("crypto"));
const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
const bcrypt_1 = __importDefault(require("bcrypt"));
const https_1 = __importDefault(require("https"));
const http_1 = __importDefault(require("http"));
const url_1 = require("url");
const security = __importStar(require("./security"));
const worker = __importStar(require("./worker"));
const toon = __importStar(require("./toon"));
const ai = __importStar(require("./ai"));
// Random İşlemler
function makeUniqueId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2);
}
function randomArray(arr) {
    return arr[Math.floor(Math.random() * arr.length)];
}
function randomText(length = 8) {
    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join("");
}
function randomNumber(min = 0, max = 9999999) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
function randomEmoji() {
    const emojiler = ["😄", "😃", "😀", "😊", "😉", "😍", "😘", "😚", "😜", "😝", "😛", "😁"];
    return emojiler[Math.floor(Math.random() * emojiler.length)];
}
function randomHex() {
    return `#${Array.from({ length: 6 }, () => "0123456789ABCDEF".charAt(Math.floor(Math.random() * 16))).join("")}`;
}
function randomFloat(min, max) {
    return Math.random() * (max - min) + min;
}
// String İşlemleri
function titleCase(sentence) {
    return sentence
        .toLowerCase()
        .split(" ")
        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
        .join(" ");
}
function generateRandomString(length) {
    return randomText(length);
}
function generateSlug(text) {
    return text
        .toLowerCase()
        .replace(/[^a-z0-9]+/g, "-")
        .replace(/^-+|-+$/g, "");
}
function wordCount(text) {
    return text.trim().split(/\s+/).length;
}
// Array İşlemleri
function shuffleArray(array) {
    const arr = [...array];
    let currentIndex = arr.length;
    while (currentIndex !== 0) {
        const randomIndex = Math.floor(Math.random() * currentIndex);
        currentIndex--;
        [arr[currentIndex], arr[randomIndex]] = [arr[randomIndex], arr[currentIndex]];
    }
    return arr;
}
function flattenArray(arr) {
    return arr.reduce((flat, toFlatten) => flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten), []);
}
function removeFalsyValues(arr) {
    return arr.filter(Boolean);
}
function groupBy(arr, key) {
    return arr.reduce((result, item) => {
        const group = String(item[key]);
        if (!result[group])
            result[group] = [];
        result[group].push(item);
        return result;
    }, {});
}
function pluck(arr, key) {
    return arr.map((item) => item[key]);
}
function sortBy(arr, key) {
    return [...arr].sort((a, b) => (a[key] > b[key] ? 1 : -1));
}
// Object İşlemleri
function filterObjectByKey(obj, keys) {
    return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
}
function deepMerge(obj1, obj2) {
    const isObject = (obj) => obj && typeof obj === "object";
    return Object.keys({ ...obj1, ...obj2 }).reduce((result, key) => {
        result[key] =
            isObject(obj1[key]) && isObject(obj2[key])
                ? deepMerge(obj1[key], obj2[key])
                : obj2[key] ?? obj1[key];
        return result;
    }, {});
}
// Şifreleme ve Güvenlik
function getKeyFromSecret(secret) {
    const salt = Buffer.from('some_fixed_salt_for_testing_only', 'utf8');
    return crypto_1.default.pbkdf2Sync(secret, salt, 100000, 32, 'sha512');
}
function encryptText(text, secret) {
    const key = getKeyFromSecret(secret);
    const iv = crypto_1.default.randomBytes(16);
    const cipher = crypto_1.default.createCipheriv("aes-256-cbc", key, iv);
    let encrypted = cipher.update(text, "utf8", "hex");
    encrypted += cipher.final("hex");
    return { encryptedText: encrypted, iv: iv.toString('hex') };
}
function decryptText(encryptedText, secret, ivHex) {
    const key = getKeyFromSecret(secret);
    const iv = Buffer.from(ivHex, 'hex');
    const decipher = crypto_1.default.createDecipheriv("aes-256-cbc", key, iv);
    let decrypted = decipher.update(encryptedText, "hex", "utf8");
    decrypted += decipher.final("utf8");
    return decrypted;
}
function hashPassword(password) {
    const saltRounds = 10;
    return bcrypt_1.default.hashSync(password, saltRounds);
}
function verifyPassword(password, hash) {
    return bcrypt_1.default.compareSync(password, hash);
}
function generateJWT(payload, secret) {
    return jsonwebtoken_1.default.sign(payload, secret, { expiresIn: "1h" });
}
function verifyJWT(token, secret) {
    try {
        return jsonwebtoken_1.default.verify(token, secret);
    }
    catch {
        return null;
    }
}
function generateSalt() {
    return crypto_1.default.randomBytes(16).toString("hex");
}
function validateUUID(uuid) {
    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    return uuidRegex.test(uuid);
}
function isPasswordStrong(password) {
    const strongPasswordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
    return strongPasswordRegex.test(password);
}
// Matematiksel İşlemler
function mean(arr) {
    if (!arr.length)
        return 0;
    return arr.reduce((sum, num) => sum + num, 0) / arr.length;
}
function median(arr) {
    if (!arr.length)
        return 0;
    const sorted = [...arr].sort((a, b) => a - b);
    const mid = Math.floor(sorted.length / 2);
    return sorted.length % 2 !== 0
        ? sorted[mid]
        : (sorted[mid - 1] + sorted[mid]) / 2;
}
function variance(arr) {
    if (!arr.length)
        return 0;
    const avg = mean(arr);
    return arr.reduce((sum, num) => sum + Math.pow(num - avg, 2), 0) / arr.length;
}
function standardDeviation(arr) {
    return Math.sqrt(variance(arr));
}
function sum(arr) {
    return arr.reduce((total, num) => total + num, 0);
}
function max(arr) {
    return Math.max(...arr);
}
function min(arr) {
    return Math.min(...arr);
}
function range(start, end) {
    if (start > end)
        return [];
    return Array.from({ length: end - start + 1 }, (_, i) => start + i);
}
function isPrime(num) {
    if (num <= 1)
        return false;
    if (num <= 3)
        return true;
    if (num % 2 === 0 || num % 3 === 0)
        return false;
    for (let i = 5; i * i <= num; i += 6) {
        if (num % i === 0 || num % (i + 2) === 0)
            return false;
    }
    return true;
}
function factorial(n) {
    if (n === 0 || n === 1)
        return 1;
    return n * factorial(n - 1);
}
function combination(n, r) {
    return factorial(n) / (factorial(r) * factorial(n - r));
}
function permutation(n, r) {
    return factorial(n) / factorial(n - r);
}
// Tarih ve Saat İşlemleri
function formatDate(date, format = "YYYY-MM-DD") {
    const options = {
        year: "numeric",
        month: "2-digit",
        day: "2-digit",
        hour: "2-digit",
        minute: "2-digit",
        second: "2-digit",
        hour12: false
    };
    const formattedDate = new Intl.DateTimeFormat("en-US", options).format(date);
    const match = formattedDate.match(/\d+/g);
    if (!match)
        return "";
    const [month, day, year, hour, minute, second] = match;
    return format
        .replace("YYYY", year)
        .replace("MM", month)
        .replace("DD", day)
        .replace("HH", hour)
        .replace("mm", minute)
        .replace("ss", second);
}
function dateDifference(date1, date2) {
    const diffTime = Math.abs(date2.getTime() - date1.getTime());
    return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
}
function addDays(date, days) {
    const result = new Date(date);
    result.setDate(result.getDate() + days);
    return result;
}
function subtractDays(date, days) {
    const result = new Date(date);
    result.setDate(result.getDate() - days);
    return result;
}
// HTTP İşlemleri
function fetchData(url) {
    return new Promise((resolve, reject) => {
        const client = url.startsWith("https") ? https_1.default : http_1.default;
        client
            .get(url, (response) => {
            let data = "";
            response.on("data", (chunk) => {
                data += chunk;
            });
            response.on("end", () => {
                try {
                    resolve(JSON.parse(data));
                }
                catch (error) {
                    resolve(data);
                }
            });
        })
            .on("error", (error) => {
            reject(error);
        });
    });
}
function postData(url, data) {
    return new Promise((resolve, reject) => {
        const client = url.startsWith("https") ? https_1.default : http_1.default;
        const parsedUrl = new url_1.URL(url);
        const options = {
            hostname: parsedUrl.hostname,
            port: parsedUrl.port || (url.startsWith("https") ? 443 : 80),
            path: parsedUrl.pathname,
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "Content-Length": Buffer.byteLength(JSON.stringify(data)),
            },
        };
        const req = client.request(options, (response) => {
            let responseData = "";
            response.on("data", (chunk) => {
                responseData += chunk;
            });
            response.on("end", () => {
                try {
                    resolve(JSON.parse(responseData));
                }
                catch (error) {
                    resolve(responseData);
                }
            });
        });
        req.on("error", (error) => {
            reject(error);
        });
        req.write(JSON.stringify(data));
        req.end();
    });
}
// Validasyon İşlemleri
function isEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}
function isPhone(phone) {
    const phoneRegex = /^[\\+]?[1-9][\\d]{0,15}$/;
    return phoneRegex.test(phone.replace(/[\\s\-\(\)]/g, ''));
}
function isURL(url) {
    try {
        new url_1.URL(url);
        return true;
    }
    catch {
        return false;
    }
}
function sanitizeHTML(html) {
    return html
        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
        .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
        .replace(/javascript:/gi, '')
        .replace(/on\w+\s*=/gi, '');
}
function validateCreditCard(cardNumber) {
    const cleanNumber = cardNumber.replace(/\D/g, '');
    if (cleanNumber.length < 13 || cleanNumber.length > 19)
        return false;
    let sum = 0;
    let isEven = false;
    for (let i = cleanNumber.length - 1; i >= 0; i--) {
        let digit = parseInt(cleanNumber[i]);
        if (isEven) {
            digit *= 2;
            if (digit > 9)
                digit -= 9;
        }
        sum += digit;
        isEven = !isEven;
    }
    return sum % 10 === 0;
}
function validateSchema(data, schema) {
    const errors = [];
    for (const [key, rules] of Object.entries(schema)) {
        const value = data[key];
        if (rules.required && (value === undefined || value === null || value === '')) {
            errors.push(`${key} alanı zorunludur`);
            continue;
        }
        if (value !== undefined && value !== null) {
            if (rules.type && typeof value !== rules.type) {
                errors.push(`${key} alanı ${rules.type} tipinde olmalıdır`);
            }
            if (rules.minLength && String(value).length < rules.minLength) {
                errors.push(`${key} en az ${rules.minLength} karakter olmalıdır`);
            }
            if (rules.maxLength && String(value).length > rules.maxLength) {
                errors.push(`${key} en fazla ${rules.maxLength} karakter olmalıdır`);
            }
            if (rules.pattern && !rules.pattern.test(String(value))) {
                errors.push(`${key} geçerli formatta değil`);
            }
            if (rules.min && value < rules.min) {
                errors.push(`${key} en az ${rules.min} olmalıdır`);
            }
            if (rules.max && value > rules.max) {
                errors.push(`${key} en fazla ${rules.max} olmalıdır`);
            }
        }
    }
    return {
        isValid: errors.length === 0,
        errors
    };
}
function sanitizeInput(input, options = {}) {
    if (typeof input !== 'string')
        return input;
    let sanitized = input;
    if (options.trim !== false) {
        sanitized = sanitized.trim();
    }
    if (options.removeHTML) {
        sanitized = sanitizeHTML(sanitized);
    }
    if (options.escape) {
        sanitized = sanitized
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#x27;');
    }
    return sanitized;
}
class Logger {
    constructor(options = {}) {
        this.levels = {
            error: 0,
            warn: 1,
            info: 2,
            debug: 3
        };
        this.colors = {
            error: '\x1b[31m',
            warn: '\x1b[33m',
            info: '\x1b[36m',
            debug: '\x1b[35m',
            reset: '\x1b[0m'
        };
        this.level = options.level || 'info';
        this.enableColors = options.enableColors !== false;
        this.enableTimestamp = options.enableTimestamp !== false;
        this.logFile = options.logFile || null;
    }
    shouldLog(level) {
        return this.levels[level] <= this.levels[this.level];
    }
    formatMessage(level, message, data) {
        let formatted = '';
        if (this.enableTimestamp) {
            formatted += `[${new Date().toISOString()}] `;
        }
        if (this.enableColors) {
            formatted += `${this.colors[level]}[${level.toUpperCase()}]${this.colors.reset} `;
        }
        else {
            formatted += `[${level.toUpperCase()}] `;
        }
        formatted += message;
        if (data !== undefined) {
            formatted += ' ' + (typeof data === 'object' ? JSON.stringify(data, null, 2) : data);
        }
        return formatted;
    }
    writeToFile(message) {
        if (this.logFile) {
            const fs = require('fs');
            const timestamp = new Date().toISOString();
            const logEntry = `${timestamp} ${message}\n`;
            try {
                fs.appendFileSync(this.logFile, logEntry);
            }
            catch (error) {
                console.error('Log dosyasına yazılamadı:', error.message);
            }
        }
    }
    log(level, message, data) {
        if (!this.shouldLog(level))
            return;
        const formatted = this.formatMessage(level, message, data);
        if (level === 'error') {
            console.error(formatted);
        }
        else if (level === 'warn') {
            console.warn(formatted);
        }
        else {
            console.log(formatted);
        }
        this.writeToFile(formatted);
    }
    error(message, data) { this.log('error', message, data); }
    warn(message, data) { this.log('warn', message, data); }
    info(message, data) { this.log('info', message, data); }
    debug(message, data) { this.log('debug', message, data); }
    setLevel(level) {
        if (this.levels.hasOwnProperty(level)) {
            this.level = level;
        }
        else {
            throw new Error(`Geçersiz log seviyesi: ${level}`);
        }
    }
    getLevel() { return this.level; }
}
exports.Logger = Logger;
function createLogger(options = {}) {
    return new Logger(options);
}
const defaultLogger = new Logger();
function logInfo(message, data) { defaultLogger.info(message, data); }
function logError(message, data) { defaultLogger.error(message, data); }
function logWarn(message, data) { defaultLogger.warn(message, data); }
function logDebug(message, data) { defaultLogger.debug(message, data); }
// Grouped exports
exports.http_module = {
    fetchData,
    postData,
};
exports.date_module = {
    formatDate,
    dateDifference,
    addDays,
    subtractDays,
};
exports.random_module = {
    makeUniqueId,
    randomArray,
    randomText,
    randomNumber,
    randomEmoji,
    randomHex,
    randomFloat,
};
exports.string_module = {
    titleCase,
    generateRandomString,
    generateSlug,
    wordCount,
};
exports.array_module = {
    shuffleArray,
    flattenArray,
    removeFalsyValues,
    groupBy,
    pluck,
    sortBy,
};
exports.object_module = {
    filterObjectByKey,
    deepMerge,
};
exports.crypto_module = {
    encryptText,
    decryptText,
    hashPassword,
    verifyPassword,
    generateJWT,
    verifyJWT,
    generateSalt,
    validateUUID,
    isPasswordStrong,
};
exports.math_module = {
    mean,
    median,
    variance,
    standardDeviation,
    sum,
    max,
    min,
    range,
    isPrime,
    combination,
    permutation,
};
exports.validation_module = {
    isEmail,
    isPhone,
    isURL,
    sanitizeHTML,
    validateCreditCard,
    validateSchema,
    sanitizeInput,
};
exports.logger_module = {
    createLogger,
    Logger,
    info: logInfo,
    error: logError,
    warn: logWarn,
    debug: logDebug,
};
exports.security_module = {
    ...security
};
exports.worker_module = {
    ...worker
};
exports.toon_module = {
    stringify: toon.stringify,
    parse: toon.parse
};
exports.ai_module = {
    ...ai
};