someFunctions

By Sylicium

This module is a personal module that i wanted to give freely to everyone interested. Keep in mind that it might not always be up to update, regularly updated, or even updated. (by the way i'm french)

What is it ?

A bunch of utilities that you can freely use in your projects

Dependancies

require("fs"); require('node:crypto');

Functions availables

(Some might not be listed here tho)

/**
 * @version 5.0.0 // 02/08/2024
 * @author Sylicium
 * @description Module someFunction qui réunit plein de fonction utiles
 * @github https://github.com/Sylicium/someScripts/edit/main/modules/someFunctions.js
 * @discord https://discord.gg/9qPJyvJQBP
*/
import * as node_crypto from 'node:crypto';
declare class new_Random {
    version: string;
    constructor();
    /**
     * randHex() : Retourne une chaine héxadécimale de la longueur voulue
     * @param {Number} length - Longueur de la chaine voulue
     * @param {Boolean} capitalize - Mettre la chaine en caractères majuscule
     */
    randHex(length: number, capitalize?: boolean): string;
    /**
     * randInt() : Renvoie un nombre entier aléatoire entre min (inclu) et max (exclu)
     * @param {Number} min - La nombre minimum (inclu)
     * @param {Number} max - La nombre maximum (exclu)
     * @returns {Number}
     */
    randInt(min: number, max: number): number;
    /**
     * randFloat() : Renvoie un nombre flotant aléatoire entre min (inclu) et max (exclu)
     * @param {Float} min - La nombre minimum (inclu)
     * @param {Float} max - La nombre maximum (exclu)
     * @returns {Float}
     */
    randFloat(min: number, max: number): number;
    /**
     * shuffle() : Mélange aléatoirement la liste donnée.
     * @param {Array} list - La liste a mélanger
     * @returns {Array}
     */
    shuffle(list: Array<any>): Array<any>;
    /**
     * choice() : Return random elements from the list
     * @param {Array} list - Input list
     * @param {Boolean} pickOnce - Pick indexes only once for multiple choice scenarios?
     * @param {Number} amount - The amount of choosen values you want
     * @returns {Array}
     * Example:
     > choice(["toto","kiwi","salut"], false, 2) // may return ["toto","toto"] or ["kiwi","kiwi"] etc.. in some cases
     > choice(["toto","kiwi","salut"], true, 2) // will never return ["toto","toto"] or ["kiwi","kiwi"] etc..
     Careful, this rule only apply on indexes, so
     > choice(["toto","kiwi","toto"], true, 2) // may return ["toto","toto"] but this mean that indexes 0 and 2 have been choosen.
     You can remove duplicates of a list using SF.listsTools.removeDuplicates() function in that same module before passing the list in the choice() function.
     */
    choice(list: Array<any>, pickOnce?: boolean, amount?: number): any[];
    /**
     * choiceOne() : Return random 1 element of the specified list
     * @param {Array} list - Input list
     */
    choiceOne(list: Array<any>): any;
    /**
     * randString() : Retourne une chaine aléatoire de la longueur voulue contenant des lettres minusules et majuscules ainsi que des chiffres
     * @param {Number} length - Longueur de la chaine voulue
     * @param {Boolean} charListString - La liste de caractères à utiliser pour la génération de la chaine (en string)
     */
    randString(length: number, charListString?: string | undefined): string;
}
export declare const Random: new_Random;
declare class new_listTools {
    version: string;
    constructor();
    /**
     * sum() : Retourne la somme de tous les éléments de la liste
     * @param {Array} list - La liste en entrée
     */
    sum(list: Array<number>): number;
    /**
     * any() : Retourne true si au moins 1 élément se trouve dans les 2 listes
     * @param {Array} list - La 1ere liste
     * @param {Array} list_two - La 2ere liste
     * @param {Boolean} caseSensitive - Prendre en compte ou non la casse. Default: true
     */
    any(list: Array<any>, list_two: Array<any>, caseSensitive?: boolean): boolean;
    /**
     * arrayToChunks() : Retourne une liste contenant des chunks de la liste donnée, de taille maximum specifié
     * @param {Array} list - La liste qui doit être découpée en chunks
     * @param {Number} chunkSize - La taille maximum d'un chunk
     * @returns Array
     */
    arrayToChunks(list: Array<any>, chunkSize: number): Array<Array<any>>;
    /**
    * all() : Retourne true si tous les éléments de la liste A se trouvent dans la B
    * @param {Array} from_list - La liste qui doit être contenue intégralement dans la 2eme
    * @param {Array} list_in - La liste qui doit contenir chaque élement de la 1ere
    * @param {Boolean} caseSensitive - Prendre en compte ou non la casse. Default: true
    */
    all(from_list: Array<any>, list_in: Array<any>, caseSensitive?: boolean): boolean;
    /**
     * splitAndJoin() : remplace toutes les clé du dictionnaire donné par sa valeur
     * @param {String} text - Le texte à traiter
     * @param {Object} dict - Le dictionnaire sous la forme { "replaceFrom": "replaceTo", "replaceFrom2": "replaceTo2" }
     * @description example: splitAndJoin("hi how are you i ?", {"i":"UWU","are":"dont"}) -> 'hUWU how dont you UWU ?'
    */
    splitAndJoin(text: string, dict: {
        [key: string]: string;
    }): string;
    /**
     * @description Remove duplicates from a given array
     * @param {Array} list The list to use
     * @returns {Array}
     */
    removeDuplicates(list: Array<any>): Array<any>;
}
export declare const lists: new_listTools;
/**
 * isBufferEqual() : Compare deux buffer en XOR. Résiste au time attack.
 * @param {String} a - Premier buffer
 * @param {Array} b - Deuxieme buffer
 * @returns {Boolean} - Booléen
 */
declare function isBufferEqual(a: Buffer, b: Buffer): boolean;
export { isBufferEqual };
export { anyWordInText };
/**
 * anyWordInText() : Retourne true si au moins 1 élément se trouve dans le texte
 * @param {String} text - Le texte
 * @param {Array} list - La liste
 * @param {Boolean} caseSensitive - Prendre en compte ou non la casse. Default: true
 */
declare function anyWordInText(text: string, list: Array<string>, caseSensitive?: boolean): boolean;
export { mapObject };
/**
 * @description Functions that works like a Array.map((value, index)) but for objects
 * @param {Object} obj
 * @param {Function} callback
*/
declare function mapObject(obj: object, callback: Function): object;
/**
 * @description Function to check if a specific object has exactly the same keys as another object Pattern, not more, not less
 * @param {Object} pattern The pattern object
 * @param {Object} obj The object to compare
 * @returns {Boolean} True if the object has the same keys as the pattern, false otherwise
 */
export { hasSameKeys };
declare function hasSameKeys(pattern: object, obj: object): boolean;
/**
 * @description Same function but using a list for all keys
 * @example hasSameKeysList(["name","age"], {name:"toto",age:12}) -> true
 * @example hasSameKeysList(["name"], {name:"toto",age:12}) -> false
 * @example hasSameKeysList(["name","age"], {name:"toto"}) -> false
 * @param {Array} pattern The pattern list
 * @param {Object} obj The object to compare
 * @returns {Boolean} True if the object has the same keys as the pattern, false otherwise
*/
export { hasSameKeysList };
declare function hasSameKeysList(patternList: Array<any>, obj: object): boolean;
/**
 * @class JSONBigInt()
 * @author Sylicium
 * @description Allow you to use JSON.parse() and JSON.stringify() with support for BigInts
 */
declare class new_JSONBigInt {
    constructor();
    parse(json: string): JSON;
    stringify(json: JSON): string;
    _replacer(key: any, value: any): any;
    _reviver(key: any, value: any): any;
    _forceStringify(json: JSON): string;
    _forceParse(json: string): JSON;
}
export declare const JSONBigInt: new_JSONBigInt;
export { parseMillisecondsFromTimeString };
/**
 * parseMillisecondsFromTimeString(string) : Returns an amount of milliseconds from the parsed user time string input
 * @example f("10m") -> 600000 | f("1d") -> 86400000 | f("2d 10m 50s 999ms") -> 173450999
 * @param {String} str - The text to parse
 * @returns {Number}
 */
declare function parseMillisecondsFromTimeString(str: string): number;
export { isScam };
/**
 * isScam() : Renvoie True si le texte entré est détecté comme une arnaque Version 1.1.1 | 21/06/2022
 * @param {String} text - La chaine de texte à tester
 * @author Sylicium
 * @description Used for discord bots in my own projects
 */
declare function isScam(text: string): {
    scam: boolean;
    score: number;
    info: string;
};
export { isScamLinkScore };
/**
 * isScamLinkScore() : Retourne un booléen pour savoir si ce lien est un lien d'arnaque
 * @param {String} link - Le lien a tester
 * @deprecated Not yet coded -
 */
declare function isScamLinkScore(link: string): boolean;
/**
 * createHash() Creates a hash of the specified string using the hashType and digest format.
 * @param {String} inputString The input string to hash
 * @param {String} hashType The hash algorithm used (default sha256)
 * @param {String} digestFormat Digest format (default hex)
 */
declare function createHash(inputString: string, hashType?: string, digestFormat?: node_crypto.BinaryToTextEncoding): string;
export { createHash };
/**
 * _normalize(): Normalizes a string returning the same string without accents and special characters
 * @param {String} str The string to normalize
 * @returns String
 */
declare let _normalize: (str: string) => string;
export { _normalize };
/**
 * @description Normalize a list of strings and return a regex string
 * @param {*} list
 * @returns
 */
declare let _normalizeListRegex: (list: Array<any>) => string;
export { _normalizeListRegex };
/**
 * Returns the same string with the first letter as a capital letter
 * @param {String} str The input string
 * @returns {String}
 */
export declare const capitalize: (str: string) => string;
/**
 * formatTime() : Transforme un temps en millisecondes en un texte en une durée formatée
 * @param {string} millisecondes - Le temps en millisecondes à convertir
 * @param {string} format - Le format texte à renvoyer (YYYY: year, MM: month, DDDDD: jour de la semaine, DD: day, hh: heure, mm: minute, ss: seconde)
 */
export { formatTime };
declare function formatTime(millisecondes: number, format: string): string;
export { formatDate };
/**
 * formatDate() : Transforme un timestamp en un texte de date formatée
 * @param {string} timestamp - Le timestamp à convertir
 * @param {string} format - Le format texte à renvoyer (YYYY: year, MM: month, DDDDD: jour de la semaine, DD: day, hh: heure, mm: minute, ss: seconde)
 */
declare function formatDate(timestamp: number | bigint, format: string): string;
export { compareString };
/**
 * compareString() : Renvoie une valeur entre 0 et 1 du taux de similitude entre les deux chaines
 * @param {string} string1 - Première chaine de texte
 * @param {string} string2 - Deuxième chaine de texte
 * @author Sylicium
 * @description Renvoie une valeur entre 0 et 1 du taux de similitude entre les deux chaines - When using this, please mention @sylicium
 */
declare function compareString(string1: string, string2: string): number;
/**
 * class Emitter : Create a local socket object to send and receive events.
 * @version 1.0.0
 * @author Sylicium
 */
declare class Emitter {
    eventsNames: {
        [key: string]: any;
    };
    on: Function;
    emit: Function;
    removeListeners: Function;
    removeAllListeners: Function;
    countListeners: Function;
    constructor();
}
export { Emitter };
/**
 * @description Pauses the execution for a specified amount of time in milliseconds
 * @param {Number} ms - Amount of milliseconds to wait
 * @returns {Promise} - A promise that resolves after the specified time
 */
export declare const sleep: (ms: number) => Promise<any>;