@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/functions/index.js

@@ -0,0 +1,636 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+// 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,
+};

package/dist/functions/temp_isphone.d.ts

@@ -0,0 +1 @@
+export declare function isPhone(phone: string): boolean;

package/dist/functions/temp_isphone.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPhone = isPhone;
+function isPhone(phone) {
+    const phoneRegex = /^[\+]?[1-9][\d]{0,15}$/;
+    return phoneRegex.test(phone.replace(/[\s\-\(\)]/g, ''));
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import * as database from "./database";
+import * as functions from "./functions";
+export { database, functions, };
+declare const _default: {
+    database: typeof database;
+    functions: typeof functions;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,45 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functions = exports.database = void 0;
+const database = __importStar(require("./database"));
+exports.database = database;
+const functions = __importStar(require("./functions"));
+exports.functions = functions;
+// For backward compatibility with require
+exports.default = {
+    database,
+    functions,
+};

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};